Add files using upload-large-folder tool

parse/train/-N7PBXqOUJZ/-N7PBXqOUJZ.md

@@ -0,0 +1,656 @@
+# LIPSCHITZ RECURRENT NEURAL NETWORKS
+
+N. Benjamin Erichson ICSI and UC Berkeley erichson@berkeley.edu
+
+Omri Azencot Ben-Gurion University azencot@cs.bgu.ac.il
+
+Alejandro Queiruga Google Research afq@google.com
+
+Liam Hodgkinson   
+ICSI and UC Berkeley   
+liam.hodgkinson@berkeley.edu   
+Michael W. Mahoney   
+ICSI and UC Berkeley   
+mmahoney@stat.berkeley.edu
+
+# ABSTRACT
+
+Viewing recurrent neural networks (RNNs) as continuous-time dynamical systems, we propose a recurrent unit that describes the hidden state’s evolution with two parts: a well-understood linear component plus a Lipschitz nonlinearity. This particular functional form facilitates stability analysis of the long-term behavior of the recurrent unit using tools from nonlinear systems theory. In turn, this enables architectural design decisions before experimentation. Sufficient conditions for global stability of the recurrent unit are obtained, motivating a novel scheme for constructing hidden-to-hidden matrices. Our experiments demonstrate that the Lipschitz RNN can outperform existing recurrent units on a range of benchmark tasks, including computer vision, language modeling and speech prediction tasks. Finally, through Hessian-based analysis we demonstrate that our Lipschitz recurrent unit is more robust with respect to input and parameter perturbations as compared to other continuous-time RNNs.
+
+# 1 INTRODUCTION
+
+Many interesting problems exhibit temporal structures that can be modeled with recurrent neural networks (RNNs), including problems in robotics, system identification, natural language processing, and machine learning control. In contrast to feed-forward neural networks, RNNs consist of one or more recurrent units that are designed to have dynamical (recurrent) properties, thereby enabling them to acquire some form of internal memory. This equips RNNs with the ability to discover and exploit spatiotemporal patterns, such as symmetries and periodic structures (Hinton, 1986). However, RNNs are known to have stability issues and are notoriously difficult to train, most notably due to the vanishing and exploding gradients problem (Bengio et al., 1994; Pascanu et al., 2013).
+
+Several recurrent models deal with the vanishing and exploding gradients issue by restricting the hidden-to-hidden weight matrix to be an element of the orthogonal group (Arjovsky et al., 2016; Wisdom et al., 2016; Mhammedi et al., 2017; Vorontsov et al., 2017; Lezcano-Casado & MartinezRubio, 2019). While such an approach is advantageous in maintaining long-range memory, it limits the expressivity of the model. To address this issue, recent work suggested to construct hidden-tohidden weights which have unit norm eigenvalues and can be nonnormal (Kerg et al., 2019). Another approach for resolving the exploding/vanishing gradient problem has recently been proposed by Kag et al. (2020), who formulate the recurrent units as a differential equation and update the hidden states based on the difference between predicted and previous states.
+
+In this work, we address these challenges by viewing RNNs as dynamical systems whose temporal evolution is governed by an abstract system of differential equations with an external input. The data are formulated in continuous-time where the external input is defined by the function $x = x ( t ) \in \mathbb { R } ^ { p }$ , and the target signal is defined as $\boldsymbol { y } = \boldsymbol { y } ( t ) \in \mathbb { R } ^ { d }$ . Based on insights from dynamical systems theory, we propose a continuous-time Lipschitz recurrent neural network with the functional form
+
+$$
+\left\{ \begin{array} { r c l } { { \dot { h } } } & { { = } } & { { A _ { \beta _ { A } , \gamma _ { A } } h + \operatorname { t a n h } ( W _ { \beta _ { W } , \gamma _ { W } } h + U x + b ) , } } \\ { { y } } & { { = } } & { { D h , } } \end{array} \right.
+$$
+
+where the hidden-to-hidden matrices $A _ { \beta , \gamma } \in \mathbb { R } ^ { N \times N }$ and $W _ { \beta , \gamma } \in \mathbb { R } ^ { N \times N }$ are of the form
+
+$$
+\left\{ \begin{array} { r l } { A _ { \beta _ { A } , \gamma _ { A } } } & { = ( 1 - \beta _ { A } ) ( M _ { A } + M _ { A } ^ { T } ) + \beta _ { A } ( M _ { A } - M _ { A } ^ { T } ) - \gamma _ { A } I } \\ { W _ { \beta _ { W } , \gamma _ { W } } } & { = ( 1 - \beta _ { W } ) ( M _ { W } + M _ { W } ^ { T } ) + \beta _ { W } ( M _ { W } - M _ { W } ^ { T } ) - \gamma _ { W } I , } \end{array} \right.
+$$
+
+where $\beta _ { A } , \beta _ { W } \in [ 0 , 1 ]$ , $\gamma _ { A } , \gamma _ { W } > 0$ are tunable parameters and $M _ { A } , M _ { W } \in \mathbb { R } ^ { N \times N }$ are trainable matrices. Here, $h = h ( t ) \in \mathbb { R } ^ { N }$ is a function of time $t$ that represents an internal (hidden) state, and $\begin{array} { r } { \dot { h } = \frac { \partial h ( t ) } { \partial t } } \end{array}$ is its time derivative. The hidden state represents the memory that the system has of its past. The function in Eq. (1) is parameterized by the hidden-to-hidden weight matrices $A \in \mathbb { R } ^ { N \times N }$ and $W \in \mathbb { R } ^ { N \times N }$ , the input-to-hidden encoder matrix $U \in \mathbb { R } ^ { N \times p }$ , and an offset $b$ . The function in Eq. (1b) is parameterized by the hidden-to-output decoder matrix $D \in \mathbb { R } ^ { d \times N }$ . Nonlinearity is introduced via the 1-Lipschitz tanh activation function. While RNNs that are governed by differential equations with an additive structure have been studied before (Zhang et al., 2014), the specific formulation that we propose in (1) and our theoretical analysis are distinct.
+
+Treating RNNs as dynamical systems enables studying the long-term behavior of the hidden state with tools from stability analysis. From this point of view, an unstable unit presents an exploding gradient problem, while a stable unit has well-behaved gradients over time (Miller & Hardt, 2019). However, a stable recurrent unit can suffer from vanishing gradients, leading to catastrophic forgetting (Hochreiter & Schmidhuber, 1997b). Thus, we opt for a stable model whose dynamics do not (or only slowly do) decay over time. Importantly, stability is also a statement about the robustness of neural units with respect to input perturbations, i.e., stable models are less sensitive to small perturbations compared to unstable models. Recently, Chang et al. (2019) explored the stability of linearized RNNs and provided a local stability guarantee based on the Jacobian. In contrast, the particular structure of our unit (1) allows us to obtain guarantees of global exponential stability using control theoretical arguments. In turn, the sufficient conditions for global stability motivate a novel symmetric-skew decomposition based scheme for constructing hidden-to-hidden matrices. This scheme alleviates exploding and vanishing gradients, while remaining highly expressive.
+
+In summary, the main contributions of this work are as follows:
+
+• First, in Section 3, using control theoretical arguments in a direct Lyapunov approach, we provide sufficient conditions for global exponential stability of the Lipschitz RNN unit (Theorem 1). Global stability is advantageous over local stability results since it guarantees non-exploding gradients regardless of the state. In the special case where $A$ is symmetric, we find that these conditions agree with those in classical theoretical analyses (Lemma 1). • Next, in Section 4, drawing from our stability analysis, we propose a novel scheme based on the symmetric-skew decomposition for constructing hidden-to-hidden matrices. This scheme mitigates the vanishing and exploding gradients problem, while obtaining highly expressive hidden-to-hidden matrices. • In Section 6, we show that our Lipschitz RNN has the ability to outperform state-of-theart recurrent units on computer vision, language modeling and speech prediction tasks. Further, our results show that the higher-order explicit midpoint time integrator improves the predictive accuracy as compared to using the simpler one-step forward Euler scheme. Finally, in Section 7), we study our Lipschitz RNN via the lens of the Hessian and show that it is robust with respect to parameter perturbations; we also show that our model is more robust with respect to input perturbations, compared to other continuous-time RNNs.
+
+# 2 RELATED WORK
+
+The problem of vanishing and exploding gradients (and stability) have a storied history in the study of RNNs. Below, we summarize two particular approaches to the problem (constructing unitary/orthogonal RNNs and the dynamical systems viewpoint) that have gained significant attention.
+
+Unitary and orthogonal RNNs. Unitary recurrent units have received attention recently, largely due to Arjovsky et al. (2016) showing that unitary hidden-to-hidden matrices alleviate the vanishing and exploding gradients problem. Several other unitary and orthogonal models have also been proposed (Wisdom et al., 2016; Mhammedi et al., 2017; Jing et al., 2017; Vorontsov et al., 2017; Jose et al., 2018). While these approaches stabilize the training process of RNNs considerably, they also limit their expressivity and their prediction accuracy. Further, unitary RNNs are expensive to train, as they typically involve the computation of a matrix inverse at each step of training. Recent work by Lezcano-Casado & Martinez-Rubio (2019) overcame some of these limitations. By leveraging concepts from Riemannian geometry and Lie group theory, their recurrent unit exhibits improved expressivity and predictive accuracy on a range of benchmark tasks while also being efficient to train. Another competitive recurrent design was recently proposed by Kerg et al. (2019). Their approach is based on the Schur decomposition, and it enables the construction of general nonnormal hidden-to-hidden matrices with unit-norm eigenvalues.
+
+Dynamical systems inspired RNNs. The continuous time view of RNNs has a long history in the neurodynamics community as it provides higher flexibility and increased interpretability (Pineda, 1988; Pearlmutter, 1995; Zhang et al., 2014). In particular, RNNs that are governed by differential equations with an additive structure have been extensively studied from a theoretical point of view (Funahashi & Nakamura, 1993; Kim et al., 1996; Chow & Li, 2000; Hu & Wang, 2002; Li et al., 2005; Trischler & D’Eleuterio, 2016). See Zhang et al. (2014) for a comprehensive survey of continuous-time RNNs and their stability properties.
+
+Recently, several works have adopted the dynamical systems perspective to alleviate the challenges of training RNNs which are related to the vanishing and exploding gradients problem. For nonsequential data, Ciccone et al. (2018) proposed a negative-definite parameterization for enforcing stability in the RNN during training. Chang et al. (2019) introduced an antisymmetric hidden-tohidden weight matrix and provided guarantees for local stability. Kag et al. (2020) have proposed a differential equation based formulation for resolving the exploding/vanishing gradients problem by updating the hidden states based on the difference between predicted and previous states. Niu et al. (2019) employed numerical methods for differential equations to study the stability of RNNs.
+
+Another line of recent work has focused on continuous-time models that deal with irregular sampled time-series, missing values and multidimensional time series. Rubanova et al. (2019) and De Brouwer et al. (2019) formulated novel recurrent models based on the theory of differential equations and their discrete integration. Lechner & Hasani (2020) extended these ordinary differential equation (ODE) based models and addresses the issue of vanishing and exploding gradients by designing an ODE-model that is based on the idea of long short-term memory (LSTM). This ODE-LSTM outperforms the continuous-time LSTM (Mei & Eisner, 2017) as well as the GRU-D model (Che et al., 2018) that is based on a gated recurrent unit (GRU).
+
+The link between dynamical systems and models for forecasting sequential data also provides the opportunity to incorporate physical knowledge into the learning process which improves the generalization performance, robustness, and ability to learn with limited data (Chen et al., 2019).
+
+# 3 STABILITY ANALYSIS OF LIPSCHITZ RECURRENT UNITS
+
+One of the key contributions in this work is that we prove that model (1) is globally exponentially stable under some mild conditions on $A$ and $W$ . Namely, for any initial hidden state we can guarantee that our Lipschitz unit converges to an equilibrium if it exists, and therefore, gradients can never explode. We improve upon recent work on stability in recurrent models, which provide only a local analysis, see e.g., (Chang et al., 2019). In fact, global exponential stability is among the strongest notions of stability in nonlinear systems theory, implying all other forms of Lyapunov stability about the equilibrium $h ^ { * }$ (Khalil, 2002, Definitions 4.4 and 4.5).
+
+Definition 1. A point $h ^ { * }$ is an equilibrium point of $\dot { h } = f ( h , t )$ if $f ( h ^ { * } , t ) = 0$ for all $t$ . Such a point is globally exponentially stable if there exists some $C > 0$ and $\lambda > 0$ such that for any choice of initial values $h ( 0 ) \in \mathbb { R } ^ { N }$ ,
+
+$$
+\| h ( t ) - h ^ { * } \| \leq C e ^ { - \lambda t } \| h ( 0 ) - h ^ { * } \| , \quad f o r a n y t \geq 0 .
+$$
+
+The presence of a Lipschitz nonlinearity in (1) plays an important role in our analysis. While we focus on tanh in our experiments, our proof is more general and is applicable to models whose nonlinearity $\sigma ( \cdot )$ is an $M$ -Lipschitz function. Specifically, we consider the general model
+
+$$
+\dot { h } = A h + \sigma ( W h + U x + b ) ,
+$$
+
+for which we have the following stability result. In the following, we let $\sigma _ { \mathrm { m i n } }$ and $\sigma _ { \mathrm { m a x } }$ denote the smallest and largest singular values of the hidden-to-hidden matrices, respectively.
+
+Theorem 1. Let $h ^ { * }$ be an equilibrium point of a differential equation of the form (4) for some $x \in \mathbb { R } ^ { p }$ . The point $h ^ { * }$ is globally exponentially stable if the eigenvalues of $A ^ { \mathrm { s y m } } : = \textstyle { \frac { 1 } { 2 } } ( { \dot { A } } + A ^ { T } )$ are strictly negative, $W$ is non-singular, and either (a) $\sigma _ { \mathrm { m i n } } ( A ^ { \mathrm { s y m } } ) > M \sigma _ { \mathrm { m a x } } ( W )$ ; or (b) $\sigma$ is monotone non-decreasing, $W + W ^ { \ ' T }$ is negative definite, and $\Dot { A } ^ { T } W + W ^ { T } A$ is positive definite.
+
+The two cases show that global exponential stability is guaranteed if either (a) the matrix $A$ has eigenvalues with real parts sufficiently negative to counteract expanding trajectories in the nonlinearity; or (b) the nonlinearity is monotone, both $A$ and $W$ yield stable linear systems ${ \dot { u } } = A u$ , $\dot { v } = W v$ , and $A , W$ have sufficiently similar eigenvectors. In practice, case (b) occasionally holds, but is challenging to ensure without assuming specific structure on $A$ , W . Because such assumptions could limit the expressiveness of the model, the next section will develop a tunable formulation for $A$ and $W$ with the capacity to ensure that case (a) holds.
+
+In Appendix A.1, we provide a proof of Theorem 1 using a direct Lyapunov approach. One advantage of this approach is that the driving input $x$ is permitted to evolve in time arbitrarily in the analysis. The proof relies on the classical Kalman-Yakubovich-Popov lemma and circle criterion from control theory — to our knowledge, these tools have not been applied in the modern RNN literature, and we hope our proof can illustrate their value to the community.
+
+In the special case where $A$ is symmetric and $x ( t )$ constant, we show that we can also inherit criteria for both local and global stability from a class of well-studied Cohen–Grossberg–Hopfield models.
+
+Lemma 1. Suppose that $A$ is symmetric and $W$ is nonsingular. There exists a diagonal matrix $D \in \mathbb { R } ^ { N \times N }$ , and nonsingular matrices $L , V \in \mathbb { R } ^ { N \times N }$ such that an equilibrium of (4) is (globally exponentially) stable if and only if there is a corresponding (globally exponentially) stable equilibrium for the system
+
+$$
+\dot { z } = D z + L \sigma ( V z + U x + b ) .
+$$
+
+For a thorough review of analyses of (5), see (Zhang et al., 2014). In this special case, the criteria in Theorem 1 coincide with those obtained for the corresponding model (5). However, in practice, we will not choose $A$ to be symmetric.
+
+# 4 SYMMETRIC-SKEW HIDDEN-TO-HIDDEN MATRICES
+
+In this section we propose a novel scheme for constructing hidden-to-hidden matrices. Specifically, based on the successful application of skew-symmetric hidden-to-hidden weights in several recent recurrent architectures, and our stability criteria in Theorem 1, we propose an effective symmetricskew decomposition for hidden matrices. Our decomposition allows for a simple control of the matrix spectrum while retaining its wide expressive range, enabling us to satisfy the spectral constraints derived in the previous section on both $A$ and $W$ . The proposed scheme also accounts for the issue of vanishing gradients by reducing the magnitude of large negative eigenvalues.
+
+Recently, several methods used skew-symmetric matrices, i.e., $S + S ^ { T } = 0$ to parameterize the recurrent weights $W \in \mathbb { R } ^ { N \times N }$ , see e.g., (Wisdom et al., 2016; Chang et al., 2019). From a stability analysis viewpoint, there are two main advantages for using skew-symmetric weights: these matrices generate the orthogonal group whose elements are isometric maps and thus preserve norms (Lezcano-Casado & Martinez-Rubio, 2019); and the spectrum of skew-symmetric matrices is purely imaginary which simplifies stability analysis (Chang et al., 2019). The main shortcoming of this parametrization is its reduced expressivity, as these matrices have fewer than half of the parameters of a full matrix (Kerg et al., 2019). The latter limiting aspect can be explained from a dynamical systems perspective: skew-symmetric matrices can only describe oscillatory behavior, whereas a matrix whose eigenvalues have nonzero real parts can also encode viable growth and decay information.
+
+To address the expressivity issue, we aim for hidden matrices which on the one hand, allow to control the expansion and shrinkage of their associated trajectories, and on the other hand, will be sampled from a superset of the skew-symmetric matrices. Our analysis in Theorem 1 guarantees that Lipschitz recurrent units maintain non-expanding trajectories under mild conditions on $A$ and $W$ . Unfortunately, this proposition does not provide any information with respect to the shrinkage of paths. Here, we opt for a system whose expansion and shrinkage can be easily controlled. Formally, the latter requirement is equivalent to designing hidden weights $S$ with small $\mathcal { R } \lambda _ { i } ( S ) , i = 1 , 2 , \ldots , N .$ , where $\bar { \mathcal { R } } ( z )$ denotes the real part of $z$ . A system of the form (4) whose matrices $A$ and $W$ exhibit small spectra and satisfy the conditions of Theorem 1, will exhibit dynamics with moderate decay and growth behavior and alleviate the problem of exploding and vanishing gradients. To this end, we propose the following symmetric-skew decomposition for constructing hidden matrices:
+
+![](images/f595dc2835896c393bc98ecffe8cf60ba1a0621a64c1c5fb4d72e8da0a28bdf7.jpg)  
+Figure 1: Vector fields of hidden states that are governed by Eq. (1) trained for simple pendulum dynamics. In (a), an unstable model is shown. In (b) and (c), it can be seen that we yield models that are asymptotically stable,i.e., all trajectories are attracted by an equilibrium point. In contrast, in (d), a skew-symmetric parameterization leads to a stable model without an attracting equilibrium.
+
+$$
+S _ { \beta , \gamma } : = ( 1 - \beta ) \cdot ( M + M ^ { T } ) + \beta \cdot ( M - M ^ { T } ) - \gamma I ,
+$$
+
+where $M$ is a weight matrix, and $\beta \in [ 0 . 5 , 1 ]$ , $\gamma > 0$ are tuning parameters. In the case $( \beta , \gamma ) =$ $( 1 , 0 )$ , we recover a skew-symmetric matrix, i.e., $S _ { 1 , 0 } + S _ { 1 , 0 } ^ { T } = 0$ . The construction $S _ { \beta , \gamma }$ is useful as we can easily bound its spectrum via the parameters $\beta$ and $\gamma$ , as we show in the next proposition.
+
+eigenvalues of Proposition 1. Let $S _ { \beta , \gamma }$ , as well as the eigenvalues of satisfy $( 6 )$ , and let $M ^ { \mathrm { s y m } } = \textstyle \frac { 1 } { 2 } ( M + M ^ { T } )$ $S _ { \beta , \gamma } ^ { \mathrm { s y m } } = S _ { \beta , \gamma } + S _ { \beta , \gamma } ^ { T } ,$ . The real parts , lie in the interval $\Re \lambda _ { i } ( S _ { \beta , \gamma } )$ of the
+
+$$
+[ ( 1 - \beta ) \lambda _ { \mathrm { m i n } } ( M ^ { \mathrm { s y m } } ) - \gamma , ( 1 - \beta ) \lambda _ { \mathrm { m a x } } ( M ^ { \mathrm { s y m } } ) - \gamma ] .
+$$
+
+A proof is provided in Appendix A.2. We infer that $\beta$ controls the width of the spectrum, while increasing $\gamma$ shifts the spectrum to the left along the real axis, thus enforcing eigenvalues with nonpositive real parts. Choosing our hidden-to-hidden matrices to be $A _ { \beta _ { A } , \gamma _ { A } }$ and $W _ { \beta _ { W } , \gamma _ { W } }$ of the form (6) for different values of $\beta _ { A } , \beta _ { W }$ and $\gamma _ { A } , \gamma _ { W }$ , we can ensure small spectra and satisfy the conditions of Theorem 1 as desired. Note, that different tuning parameters $\beta$ and $\gamma$ affect the stability behavior of the Lipschitz recurrent unit. This is illustrated in Figure 1, where different values for $\beta$ and $\gamma$ are used to construct both $A _ { \beta , \gamma }$ and $W _ { \beta , \gamma }$ and applied to learning simple pendulum dynamics.
+
+One cannot guarantee that model parameters will remain in the stability region during training. However, we can show that when $\beta$ is taken to be close to one, the eigenvalues of $A _ { \beta , \gamma } ^ { \mathrm { s y m } }$ mγ and W symβ,γ (which dictate the stability of the RNN) change slowly during training. Let $\Delta _ { \delta } F$ denote the change in a function $F$ depending on the parameters of the RNN (1) after one step of gradient descent with step size $\delta$ with respect to some loss $L ( y )$ . For a matrix $A$ , we let $\lambda _ { k } ( A )$ denote the $k$ -th singular value of $A$ . We have the following lemma.
+
+$$
+\mathbf { L e m m a } 2 . \ A s \ \beta \to 1 ^ { - } , \operatorname* { m a x } _ { k } \left| \Delta _ { \delta } \lambda _ { k } ( A _ { \beta , \gamma } ^ { \mathrm { s y m } } ) \right| + \operatorname* { m a x } _ { k } \left| \Delta _ { \delta } \lambda _ { k } ( W _ { \beta , \gamma } ^ { \mathrm { s y m } } ) \right| = \mathcal { O } ( \delta ( 1 - \beta ) ^ { 2 } ) .
+$$
+
+Therefore, provided both the initial and optimal parameters lie within the stability region, the model parameters will remain in the stability region for longer periods of time with high probability as $\beta  1$ . Further empirical evidence of parameters often remaining in the stability region during training are provided alongside the proof of Lemma 2 in the Appendix (see Figure 5).
+
+# 5 TRAINING CONTINUOUS-TIME LIPSCHITZ RECURRENT UNITS
+
+ODEs such as Eq. (1) can be approximately solved by employing numerical integrators. In scientific computing, numerical integration is a well studied field that provides well understood techniques (LeVeque, 2007). Recent literature has also introduced new approaches which are designed with neural network frameworks in mind (Chen et al., 2018).
+
+To learn the weights $A , W , U$ and $b$ , we discretize the continuous model using one step of a numerical integrator between sequence entries. In what follows, a subscript $t$ denotes discrete time indices, $\Delta t$ represents the time difference between a pair of consecutive data points. Letting $f ( h , t ) =$ $A h + \operatorname { t a n h } ( W h + U x ( s ) + b )$ so that $\dot { h } ( t ) = f ( h , t )$ , the exact and approximate solutions for $h _ { t + 1 }$ given $h _ { t }$ are given by
+
+$$
+\begin{array} { r l r } {  { h _ { t + 1 } = h _ { t } + \int _ { t } ^ { t + \Delta t } f ( h ( s ) , s ) \mathrm { d } s : = h _ { t } + \int _ { t } ^ { t + \Delta t } A h ( s ) + \operatorname { t a n h } ( W h ( s ) + U x ( s ) + b ) \mathrm { d } s } } \\ & { } & { \approx h _ { t } + \Delta t \cdot \mathrm { s c h e m e } [ f , h _ { t } , \Delta t ] , } \end{array}
+$$
+
+where scheme represents one step of a numerical integration scheme whose application yields an approximate solution for $\begin{array} { r } { \frac { 1 } { \Delta t } \int _ { t } ^ { t + \Delta t } f ( h ( s ) , s ) \mathrm { d } s } \end{array}$ given $h _ { t }$ using one or more evaluations of $f$ .
+
+We consider both the explicit (forward) Euler scheme,
+
+$$
+h _ { t + 1 } = h _ { t } + \Delta t \cdot A h _ { t } + \Delta t \cdot \operatorname { t a n h } ( z _ { t } ) ,
+$$
+
+as well as the midpoint method which is a two-stage explicit Runge-Kutta scheme (RK2),
+
+$$
+h _ { t + 1 } = h _ { t } + \Delta t \cdot A { \tilde { h } } + \Delta t \cdot \operatorname { t a n h } ( W { \tilde { h } } + U x _ { t } + b ) ,
+$$
+
+where $\tilde { h } = h _ { t } + \Delta t / 2 \cdot A h _ { t } + \Delta t / 2 \cdot \operatorname { t a n h } ( z _ { t } )$ is an intermediate hidden state. The RK2 scheme can potentially improve the performance since the scheme is more accurate, however, this scheme also requires twice as many function evaluations as compared to the forward Euler scheme. Given a $\beta$ and $\gamma$ that yields a globally exponentially stable continuous model, $\Delta t$ can always be chosen so that the model remains in the stability region of forward Euler and RK2 (LeVeque, 2007).
+
+# 6 EMPIRICAL EVALUATION
+
+In this section, we evaluate the performance of the Lipschitz RNN and compare it to other state-ofthe-art methods. The model is applied to ordered and permuted pixel-by-pixel MNIST classification, as well as to audio data using the TIMIT dataset. We show the sensitivity with respect to to random initialization in Appendix B. Appendix B also contains additional results for: pixel-by-pixel CIFAR10 and a noise-padded version of CIFAR-10; as well as for character level and word level prediction using the Penn Tree Bank (PTB) dataset. All of these tasks require that the recurrent unit learns long-term dependencies: that is, the hidden-to-hidden matrices need to have sufficient memory to remember information from far in the past.
+
+# 6.1 ORDERED AND PERMUTED PIXEL-BY-PIXEL MNIST
+
+The pixel-by-pixel MNIST task tests long range dependency by sequentially presenting 784 pixels to the recurrent unit, i.e., the RNN processes one pixel at a time (Le et al., 2015). At the end of the sequence, the learned hidden state is used to predict the class membership probability of the input image. This task requires that the RNN has a sufficient long-term memory in order to discriminate between different classes. A more challenging variation to this task is to operate on a fixed random permutation of the input sequence.
+
+Table 1: Evaluation accuracy on ordered and permuted pixel-by-pixel MNIST.   
+
+<table><tr><td>Name</td><td>ordered</td><td> permuted</td><td>N</td><td># params</td></tr><tr><td>LSTM baseline by (Arjovsky et al., 2016)</td><td>97.3%</td><td>92.7%</td><td>128</td><td>~68K</td></tr><tr><td>MomentumLSTM (Nguyen et al.,2020)</td><td>99.1%</td><td>94.7%</td><td>256</td><td>~270K</td></tr><tr><td>Unitary RNN (Arjovsky et al., 2016)</td><td>95.1%</td><td>91.4%</td><td>512</td><td>~9K</td></tr><tr><td>Full Capacity Unitary RNN (Wisdom et al., 2016)</td><td>96.9%</td><td>94.1%</td><td>512</td><td>~270K</td></tr><tr><td>Soft orth. RNN (Vorontsov et al.,2017)</td><td>94.1%</td><td>91.4%</td><td>128</td><td>~18K</td></tr><tr><td>Kronecker RNN(Jose et al.,2018)</td><td>96.4%</td><td>94.5%</td><td>512</td><td>~11K</td></tr><tr><td>Antisymmteric RNN (Chang et al., 2019)</td><td>98.0%</td><td>95.8%</td><td>128</td><td>~10K</td></tr><tr><td>Incremental RNN (Kag et al., 2020)</td><td>98.1%</td><td>95.6%</td><td>128</td><td>~4K/8K</td></tr><tr><td>Exponential RNN (Lezcano-Casado &amp; Martinez-Rubio,2019)</td><td>98.4%</td><td>96.2%</td><td>360</td><td>~69K</td></tr><tr><td>Sequential NAIS-Net (Ciccone et al., 2018)</td><td>94.3%</td><td>90.8%</td><td>128</td><td>~18K</td></tr><tr><td>Lipschitz RNN using Euler (ours)</td><td>99.0%</td><td>94.2%</td><td>64</td><td>~9K</td></tr><tr><td>Lipschitz RNN using RK2 (ours)</td><td>99.1%</td><td>94.2%</td><td>64</td><td>~9K</td></tr><tr><td>Lipschitz RNN using Euler (ours)</td><td>99.4%</td><td>96.3%</td><td>128</td><td>~34K</td></tr><tr><td>Lipschitz RNN using RK2 (ours)</td><td>99.3%</td><td>96.2%</td><td>128</td><td>~34K</td></tr></table>
+
+Table 2: Evaluation on TIMIT using 1 layer models. The mean squared error (MSE) is computes the distance between the predicted and actual log-magnitudes of each predicted frame in the sequence.   
+
+<table><tr><td>Name</td><td>val. MSE</td><td>test MSE</td><td>N</td><td># params</td></tr><tr><td>LSTM (Helfrich et al., 2018)</td><td>13.66</td><td>12.62</td><td>158</td><td>~200K</td></tr><tr><td>LSTM (Nguyen et al., 2020)</td><td>9.33</td><td>9.37</td><td>158</td><td>~200K</td></tr><tr><td>MomentumLSTM (Nguyen et al., 2020)</td><td>5.86</td><td>5.87</td><td>158</td><td>~200K</td></tr><tr><td>SRLSTM (Nguyen et al., 2020)</td><td>5.81</td><td>5.83</td><td>158</td><td>~200K</td></tr><tr><td>Full-capacity Unitary RNN (Wisdom et al., 2016)</td><td>14.41</td><td>14.45</td><td>256</td><td>~200K</td></tr><tr><td>Cayley RNN (Helfrich et al.,2018)</td><td>7.97</td><td>7.36</td><td>425</td><td>~200K</td></tr><tr><td>Exponential RNN (Lezcano-Casado &amp; Martinez-Rubio,2019)</td><td>5.52</td><td>5.48</td><td>425</td><td>~200K</td></tr><tr><td>Lipschitz RNN using Euler (ours)</td><td>2.95</td><td>2.82</td><td>256</td><td>~198K</td></tr><tr><td>Lipschitz RNN using RK2 (ours)</td><td>2.86</td><td>2.76</td><td>256</td><td>~198K</td></tr></table>
+
+Table 1 provides a summary of our results. The Lipschitz RNN, with hidden dimension of $N = 1 2 8$ and trained with the forward Euler and RK2 scheme, achieves $9 9 . 4 \%$ and $9 9 . 3 \%$ accuracy on the ordered pixel-by-pixel MNIST task. For the permuted task, the model trained with forward Euler achieves $9 6 . 3 \%$ accuracy, whereas the model trained with RK2 achieves $9 6 . 2 \%$ accuracy. Hence, our Lipschitz recurrent unit outperforms state-of-the-art RNNs on both tasks and is competitive even when a hidden dimension of $N = 6 4$ is used, however, it can be seen that a larger unit with more capacity is advantageous for the permuted task. Our results show that we significantly outperform the Antisymmetric RNN (Chang et al., 2019) on the ordered tasks, while using fewer weights. That shows that the antisymmetric weight paramterization is limiting the expressivity of the recurrent unit. The exponential RNN is the next most competitive model, yet this model requires a larger hidden-to-hidden unit to perform well on the two considered tasks.
+
+# 6.2 TIMIT
+
+Next, we consider the TIMIT dataset (Garofolo, 1993) to study the capabilities of the Lipschitz RNN for speech prediction using audio data. For our experiments, we used the publicly available implementation of this task by Lezcano-Casado & Martinez-Rubio (2019). This implementation applies the preprocessing steps suggested by Wisdom et al. (2016): (i) downsample each audio sequence to 8kHz; (ii) process the downsampled sequences with a short-time Fourier transform using a Hann window of 256 samples and a window hop of 128 samples; and (iii) normalize the logmagnitude of the Fourier amplitudes. We obtain a set of frames that each have 129 complex-valued Fourier amplitudes and the task is to predict the log-magnitude of future frames. To compare our results with those of other models, we used the common train / validation / test split: 3690 utterances from 462 speakers for training, 192 utterances for validation, and 400 utterances for testing.
+
+Table 2 lists the results for the Lipschitz recurrent unit as well as for several benchmark models. It can be seen that the Lipschitz RNN outperforms other state-of-the-art models for a fixed number of parameters $( \approx 2 0 0 \mathrm { { K } ) }$ ). In particular, LSTMs do not perform well on this task, however, the recently proposed momentum based LSTMs (Nguyen et al., 2020) have improvemed performance. Interestingly, the RK2 scheme leads to a better performance since this scheme provides more accurate approximations for the intermediate states.
+
+# 7 ROBUSTNESS WITH RESPECT TO PERTURBATIONS
+
+An important consideration beyond accuracy is robustness with respect to input and parameter perturbations. We consider a Hessian-based analysis and noise-response analysis of different continuous-time recurrent units and train the models on MNIST. Here, we reshape each MNIST thumbnail into sequences of length 98 so that each input has dimension $x \in \mathbb { R } ^ { 8 }$ . We consider this simpler problem so that all models obtain roughly the same training loss. Here we use stochastic gradient decent (SGD) with momentum to train the models.
+
+Eigenanalysis of the Hessian provides a tool for studying various aspects of neural networks (Hochreiter & Schmidhuber, 1997a; Sagun et al., 2017; Ghorbani et al., 2019). Here, we study the Hessian $H$ spectrum with respect to the model parameters of the recurrent unit using PyHessian (Yao et al., 2019). The Hessian provides us with insights about the curvature of the loss function $\mathcal { L }$ . This is because the Hessian is defined as the derivatives of the gradients, and thus the Hessian eigenvalues describe the change in the gradient of $\mathcal { L }$ as we take an infinitesimal step into a given direction. The eigenvectors span the (local) surface of the loss function at a given point, and the corresponding eigenvalue determines the curvature in the direction of the eigenvectors. This means that larger eigenvalues indicate a larger curvature, i.e., greater sensitivity, and the sign of the eigenvalues determines whether the curvature will be positive or negative.
+
+To demonstrate the advantage of the additional linear term and our weight parameterization, we compare the Lipschitz RNN to two other continuous-time recurrent units. First, we consider a simple neural ODE RNN (Rubanova et al., 2019) that takes the form
+
+$$
+\dot { h } = \operatorname { t a n h } ( W h + U x + b ) , \qquad y = D h ,
+$$
+
+where $W$ is a simple hidden-to-hidden matrix. As a second model we consider the antisymmetric RNN (Chang et al., 2019), that takes the same form as (11), but uses a skew-symmetric scheme to parameterize the hidden-to-hidden matrix as $W : = ( M - M ^ { T } ) - \gamma I$ , where $M$ is a trainable weight matrix and $\gamma$ is a tunable parameter.
+
+Table 3 reports the largest eigenvalue $\lambda _ { \operatorname* { m a x } } ( H )$ and the trace of the Hessian $\operatorname { t r } ( H )$ .The largest eigenvalue being smaller indicates that our Lipschitz RNN found a flatter minimum, as compared to the simple neural ODE and Antisymmetric RNN. It is known that such flat minima can be perturbed without significantly changing the loss value (Hochreiter & Schmidhuber, 1997a). Table 3 also reports the condition number κ(H) := λmax(H)λmin(H) of the Hessian. The condition number $\kappa ( H )$ provides a measure for the spread of the eigenvalues of the Hessian. It is known that first-order methods can slow down in situations where $\kappa$ is large (Bottou & Bousquet, 2008). The condition number and trace of our Lipshitz RNN being smaller also indicates improved robustness properties.
+
+Next, we study the sensitivity of the response $y _ { T }$ at time $T$ in terms of the test accuracy with respect to a sequence of perturbed inputs $\{ \tilde { x } _ { 1 } , \dots , \tilde { x } _ { T } \} \in \mathbb { R } ^ { 8 }$ . We consider three different perturbations. The results for the artificially constructed perturbations are presented in Table 3, showing that the Lipschitz RNN is more resilient to adversarial perturbation. Here, we have considered the projected gradient decent (PGD) (Goodfellow et al., 2014) method with $l _ { \infty }$ , and the DeepFool method (Moosavi-Dezfooli et al., 2016) with $l _ { 2 }$ and $l _ { \infty }$ norm ball perturbations. We construct the adversarial examples with full access to the models, using 7 iterations. The step size for PGD is set to 0.01.
+
+Table 3: Summary of Hessian-based robustness metrics and resilience to adversarial attacks.   
+
+<table><tr><td>Model</td><td>PGD</td><td>DF2</td><td>DF</td><td>Xmax(H)</td><td>tr(H)</td><td>K(H)</td></tr><tr><td>Neural ODE RNN</td><td>88.5%</td><td>69.6%</td><td>44.5%</td><td>0.30</td><td>4.7</td><td>37.6</td></tr><tr><td>Antisymmetric RNN</td><td>84.7%</td><td>83.4%</td><td>44.3%</td><td>0.24</td><td>4.8</td><td>35.5</td></tr><tr><td>Lipschitz RNN (ours)</td><td>93.0%</td><td>89.2%</td><td> 54.1%</td><td>0.14</td><td>3.1</td><td>23.2</td></tr></table>
+
+![](images/db19e0022bec5cb773132690be3cd53fa60bc24e6806537ffeca15668e6052b4.jpg)  
+Figure 2: Sensitivity with respect to different input perturbations.
+
+![](images/020b8a71cf5ab4e66d1dc50293f525e3a34860720d86137edfb45c4c17b0e9fd.jpg)  
+Figure 3: The ablation study examines the effect of the linear term $A h$ (in (a)) and the importance of the Skew-Symmetric Decomposition for constructing the hidden-to-hidden matrices (in (b)).
+
+Further, Figure 2 shows the results for white noise and salt and pepper noise. It can be seen that the Lipschitz unit is less sensitive to input perturbations, as compared to the simple neural ODE RNN, and the antisymmetric RNN. In addition, we also show the results for an unitary RNN here.
+
+# 7.1 ABLATION STUDY
+
+The performance of the Lipschitz recurrent unit is due to two main innovations: (i) the additional linear term; and (ii) the scheme for constructing the hidden-to-hidden matrices $A$ and $W$ in Eq. (6). Thus, we investigate the effect of both innovations, while keeping all other conditions fixed. More concretely, we consider the following ablation recurrent unit
+
+$$
+h _ { t + 1 } = h _ { t } + \alpha \cdot \epsilon \cdot A h _ { t } + \epsilon \cdot \operatorname { t a n h } ( z _ { t } ) , \quad \mathrm { w i t h } \quad z _ { t } = W h _ { t } + U x _ { t } + b ,
+$$
+
+where $\alpha$ controls the effect of the linear hidden unit. Both $A$ and $W$ depend on the parameters $\beta , \gamma$
+
+Figure 3a studies the effect of the linear hidden unit, with $\beta = 0 . 6 5$ for the ordered task and $\beta = 0 . 8$ for the permuted task. In both cases we use $\gamma = 0 . 0 0 1$ . It can be seen that the test accuracies of both the ordered and permuted pixel-by-pixel MNIST tasks clearly depend on the linear hidden unit. For $\alpha = 0$ , our models reduces to simple neural ODE recurrent units (Eq. (11)). The recurrent unit degenerates for $\alpha > 1 . 6$ , since the external input is superimposed by the hidden state. Figure 3b studies the effect of the hidden-to-hidden matrices with respect to $\beta$ . It can be seen that $\beta \ =$ $\{ 0 . 6 5 , 0 . 7 0 \}$ achieves peak performance for the ordered task, and $\beta = \{ 0 . 8 , 0 . 8 5 \}$ does so for the permuted task. Note that $\beta = 1 . 0$ recovers an skew-symmetric hidden-to-hidden matrix.
+
+# 8 CONCLUSION
+
+Viewing RNNs as continuous-time dynamical systems with input, we have proposed a new Lipschitz recurrent unit that excels on a range of benchmark tasks. The special structure of the recurrent unit allows us to obtain guarantees of global exponential stability using control theoretical arguments. In turn, the insights from this analysis motivated the symmetric-skew decomposition scheme for constructing hidden-to-hidden matrices, which mitigates the vanishing and exploding gradients problem. Due to the nice stability properties of the Lipschitz recurrent unit, we also obtain a model that is more robust with respect to input and parameter perturbations as compared to other continuoustime units. This behavior is also reflected by the Hessian analysis of the model. We expect that the improved robustness will make Lipschitz RNNs more reliable for sensitive applications. The theoretical results for our symmetric-skew decomposition of parameterizing hidden-to-hidden matrices also directly extend to the convolutional setting. Future work will explore this extension and study the potential advantages of these more parsimonious hidden-to-hidden matrices in combination with our parameterization in practice. Research code is shared via github.com/erichson/LipschitzRNN.
+
+# ACKNOWLEDGMENTS
+
+We would like to thank Ed H. Chi for fruitful discussions about physics-informed machine learning and the Antisymmetric RNN. We are grateful to the generous support from Amazon AWS and Google Cloud. NBE and MWM would like to acknowledge IARPA (contract W911NF20C0035), NSF, ONR and CLTC for providing partial support of this work. Our conclusions do not necessarily reflect the position or the policy of our sponsors, and no official endorsement should be inferred.
+
+# REFERENCES
+
+Martin Arjovsky, Amar Shah, and Yoshua Bengio. Unitary evolution recurrent neural networks. In International Conference on Machine Learning, pp. 1120–1128, 2016.
+
+Yoshua Bengio, Patrice Simard, and Paolo Frasconi. Learning long-term dependencies with gradient descent is difficult. IEEE Transactions on Neural Networks, 5(2):157–166, 1994.
+
+Rajendra Bhatia. Matrix analysis, volume 169. Springer Science & Business Media, 2013.
+
+Leon Bottou and Olivier Bousquet. The tradeoffs of large scale learning. In ´ Advances in Neural Information Processing Systems, pp. 161–168, 2008.
+
+Bo Chang, Minmin Chen, Eldad Haber, and Ed Chi. AntisymmetricRNN: A dynamical system view on recurrent neural networks. In International Conference on Learning Representations, 2019.
+
+Zhengping Che, Sanjay Purushotham, Kyunghyun Cho, David Sontag, and Yan Liu. Recurrent neural networks for multivariate time series with missing values. Scientific reports, 8(1):1–12, 2018.
+
+Tian Chen, Yulia Rubanova, Jesse Bettencourt, and David Duvenaud. Neural ordinary differential equations. In Advances in Neural Information Processing Systems, pp. 6571–6583, 2018.
+
+Zhengdao Chen, Jianyu Zhang, Martin Arjovsky, and Leon Bottou. Symplectic recurrent neural ´ networks. In International Conference on Learning Representations, 2019.
+
+Tommy W. S. Chow and Xiao-Dong Li. Modeling of continuous time dynamical systems with input by recurrent neural networks. IEEE Transactions on Circuits and Systems I: Fundamental Theory and Applications, 47(4):575–578, 2000.
+
+Marco Ciccone, Marco Gallieri, Jonathan Masci, Christian Osendorfer, and Faustino Gomez. Nais-net: Stable deep networks from non-autonomous differential equations. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett (eds.), Advances in Neural Information Processing Systems, volume 31, pp. 3025–3035. Curran Associates, Inc., 2018. URL https://proceedings.neurips.cc/paper/2018/file/ 7bd28f15a49d5e5848d6ec70e584e625-Paper.pdf.
+
+Edward De Brouwer, Jaak Simm, Adam Arany, and Yves Moreau. GRU-ODE-Bayes: Continuous modeling of sporadically-observed time series. In Advances in Neural Information Processing Systems, pp. 7379–7390. 2019.
+
+Ken-ichi Funahashi and Yuichi Nakamura. Approximation of dynamical systems by continuous time recurrent neural networks. Neural Networks, 6(6):801–806, 1993.
+
+John S. Garofolo. TIMIT acoustic phonetic continuous speech corpus. Linguistic Data Consortium, 1993.
+
+Behrooz Ghorbani, Shankar Krishnan, and Ying Xiao. An investigation into neural net optimization via Hessian eigenvalue density. In International Conference on Machine Learning, pp. 2232– 2241, 2019.
+
+Ian J. Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014.
+
+Wolfgang Hahn. Stability of motion, volume 138. Springer, 1967.
+
+Kyle Helfrich, Devin Willmott, and Qiang Ye. Orthogonal recurrent neural networks with scaled Cayley transform. In International Conference on Machine Learning, pp. 1969–1978, 2018.
+
+Mikael Henaff, Arthur Szlam, and Yann LeCun. Recurrent orthogonal networks and long-memory tasks. volume 48 of Proceedings of Machine Learning Research, pp. 2034–2042, New York, New York, USA, 20–22 Jun 2016. PMLR. URL http://proceedings.mlr.press/v48/ henaff16.html.
+
+Geoffrey E. Hinton. Learning distributed representations of concepts. In Conference of the Cognitive Science Society, volume 1, pp. 12, 1986.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Flat minima. ¨ Neural Computation, 9(1):1–42, 1997a.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural Computation, 9(8): 1735–1780, 1997b.
+
+Roger A. Horn and Charles R. Johnson. Matrix analysis. Cambridge University Press, 2012.
+
+Sanqing Hu and Jun Wang. Global stability of a class of continuous-time recurrent neural networks. IEEE Transactions on Circuits and Systems I: Fundamental Theory and Applications, 49 (9):1334–1347, 2002.
+
+Li Jing, Yichen Shen, Tena Dubcek, John Peurifoy, Scott Skirlo, Yann LeCun, Max Tegmark, and Marin Soljaciˇ c. Tunable efficient unitary neural networks (EUNN) and their application to RNNs. ´ In International Conference on Machine Learning, pp. 1733–1741, 2017.
+
+Cijo Jose, Moustapha Cisse, and Francois Fleuret. Kronecker recurrent units. In International Conference on Machine Learning, pp. 2380–2389, 2018.
+
+Anil Kag, Ziming Zhang, and Venkatesh Saligrama. RNNs incrementally evolving on an equilibrium manifold: A panacea for vanishing and exploding gradients? In International Conference on Learning Representations, 2020.
+
+Giancarlo Kerg, Kyle Goyette, Maximilian Puelma Touzel, Gauthier Gidel, Eugene Vorontsov, Yoshua Bengio, and Guillaume Lajoie. Non-normal recurrent neural network (nnRNN): Learning long time dependencies while improving expressivity with transient dynamics. In Advances in Neural Information Processing Systems, pp. 13591–13601, 2019.
+
+Hassan K. Khalil. Nonlinear Systems. Pearson Education. Prentice Hall, 2002.
+
+Young H. Kim, Frank L. Lewis, and Chaouki T. Abdallah. Nonlinear observer design using dynamic recurrent neural networks. In Proceedings of 35th IEEE Conference on Decision and Control, volume 1, pp. 949–954. IEEE, 1996.
+
+Aditya Kusupati, Manish Singh, Kush Bhatia, Ashish Kumar, Prateek Jain, and Manik Varma. Fastgrnn: A fast, accurate, stable and tiny kilobyte sized gated recurrent neural network. In Advances in Neural Information Processing Systems, pp. 9017–9028, 2018.
+
+Quoc V. Le, Navdeep Jaitly, and Geoffrey E. Hinton. A simple way to initialize recurrent networks of rectified linear units. arXiv preprint arXiv:1504.00941, 2015.
+
+Mathias Lechner and Ramin Hasani. Learning long-term dependencies in irregularly-sampled time series. arXiv preprint arXiv:2006.04418, 2020.
+
+Randall J. LeVeque. Finite Difference Methods for Ordinary and Partial Differential Equations. Society for Industrial and Applied Mathematics, 2007. doi: 10.1137/1.9780898717839.
+
+Mario Lezcano-Casado and David Martinez-Rubio. Cheap orthogonal constraints in neural networks: A simple parametrization of the orthogonal and unitary group. In International Conference on Machine Learning, pp. 3794–3803, 2019.
+
+Xiao-Dong Li, John K. L. Ho, and Tommy W. S. Chow. Approximation of dynamical time-variant systems by continuous-time recurrent neural networks. IEEE Transactions on Circuits and Systems II: Express Briefs, 52(10):656–660, 2005.
+
+Mitchell Marcus, Beatrice Santorini, and Mary Ann Marcinkiewicz. Building a large annotated corpus of English: the Penn Treebank. 1993.
+
+Hongyuan Mei and Jason M Eisner. The neural hawkes process: A neurally self-modulating multivariate point process. In Advances in Neural Information Processing Systems, pp. 6754–6764, 2017.
+
+Zakaria Mhammedi, Andrew Hellicar, Ashfaqur Rahman, and James Bailey. Efficient orthogonal parametrisation of recurrent neural networks using Householder reflections. In International Conference on Machine Learning, pp. 2401–2409, 2017.
+
+John Miller and Moritz Hardt. Stable recurrent models. In International Conference on Learning Representations, 2019.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: A simple and accurate method to fool deep neural networks. In Conference on Computer Vision and Pattern Recognition, pp. 2574–2582, 2016.
+
+Tan M. Nguyen, Richard G. Baraniuk, Andrea L. Bertozzi, Stanley J. Osher, and Bao Wang. Momentumrnn: Integrating momentum into recurrent neural networks. arXiv preprint arXiv:2006.06919, 2020.
+
+Murphy Yuezhen Niu, Lior Horesh, and Isaac Chuang. Recurrent neural networks in the eye of differential equations. arXiv preprint arXiv:1904.12933, 2019.
+
+Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. In International Conference on Machine Learning, pp. 1310–1318, 2013.
+
+Barak A. Pearlmutter. Gradient calculations for dynamic recurrent neural networks: A survey. IEEE Transactions on Neural networks, 6(5):1212–1228, 1995.
+
+Fernando J. Pineda. Dynamics and architecture for neural computation. Journal of Complexity, 4 (3):216–245, 1988.
+
+Yulia Rubanova, Tian Chen, and David Duvenaud. Latent ordinary differential equations for irregularly-sampled time series. In Advances in Neural Information Processing Systems, pp. 5321–5331, 2019.
+
+Levent Sagun, Utku Evci, V. Ugur Guney, Yann Dauphin, and Leon Bottou. Empirical analysis of the Hessian of over-parametrized neural networks. arXiv preprint arXiv:1706.04454, 2017.
+
+Shankar Sastry. Nonlinear systems: Analysis, stability, and control, volume 10. Springer Science, 2013.
+
+Adam P. Trischler and Gabriele M. T. D’Eleuterio. Synthesis of recurrent neural networks for dynamical system simulation. Neural Networks, 80:67–78, 2016.
+
+Eugene Vorontsov, Chiheb Trabelsi, Samuel Kadoury, and Chris Pal. On orthogonality and learning recurrent networks with long term dependencies. In International Conference on Machine Learning, pp. 3570–3578, 2017.
+
+Scott Wisdom, Thomas Powers, John Hershey, Jonathan Le Roux, and Les Atlas. Full-capacity unitary recurrent neural networks. In Advances in Neural Information Processing Systems, pp. 4880–4888, 2016.
+
+Zhewei Yao, Amir Gholami, Kurt Keutzer, and Michael W. Mahoney. PyHessian: Neural networks through the lens of the Hessian. arXiv preprint arXiv:1912.07145, 2019.
+
+Huaguang Zhang, Zhanshan Wang, and Derong Liu. A comprehensive review of stability analysis of continuous-time recurrent neural networks. IEEE Transactions on Neural Networks and Learning Systems, 25(7):1229–1262, 2014.
+
+# A PROOFS
+
+# A.1 PROOFS OF THEOREM 1 AND LEMMA 1
+
+There are numerous ways that one can analyze the global stability of (4) through the related model (5), many of which are discussed in Zhang et al. (2014). Instead, here we shall conduct a direct approach and avoid appealing to diagonalization in order to obtain cleaner conditions, and a more straightforward proof that readily applies in the time-inhomogeneous setting.
+
+Our method of choice relies on Lyapunov arguments summarized in the following theorem, which can be found as (Khalil, 2002, Theorem 4.10). For more details on related Lyapunov theory, see also Hahn (1967); Sastry (2013).
+
+Theorem 2. An equilibrium $h ^ { * }$ for $\dot { h } = f ( t , h )$ is globally exponentially stable if there exists $a$ continuously differentiable function $V : [ 0 , \infty ) \times \mathbb { R } ^ { N } \stackrel { } { \to } [ 0 , \infty )$ such that for all $h \in \mathbb { R } ^ { N }$ and $t \geq 0$ ,
+
+$$
+k _ { 1 } \| h - h ^ { * } \| ^ { \alpha } \leq V ( t , h ) \leq k _ { 2 } \| h - h ^ { * } \| ^ { \alpha } , \quad a n d  \quad \frac { \partial V } { \partial t } + \frac { \partial V } { \partial h } \leq - k _ { 3 } \| h - h ^ { * } \| ^ { \alpha } ,
+$$
+
+for some constants $k _ { 1 } , k _ { 2 } , k _ { 3 } , \alpha > 0 .$ . and $\dot { V } ( h ) < 0$ for $h \neq h ^ { * }$ .
+
+To simplify matters, we shall choose a Lyapunov function $V : \mathbb { R } ^ { N } \to [ 0 , \infty )$ that is independent of time. The most common type of Lyapunov function satisfying the conditions of Theorem 2 is of the form $V ( h ) = ( h - h ^ { * } ) ^ { T } \dot { P } ( h - \dot { h ^ { * } } )$ , where $P$ is a positive definite matrix. One need only show that $\dot { V } ( h ) \leq - ( h - h ^ { * } ) ^ { T } Q ( h - h ^ { * } )$ for some other positive definite matrix $Q$ to guarantee global exponential stability.
+
+The construction of the Lyapunov function $V$ that satisfies the conditions of Theorem 2 is accomplished using the Kalman-Yakubovich-Popov lemma, which is a statement regarding strictly positive real transfer functions. We use the following definition, equivalent to other standard definitions by (Khalil, 2002, Lemma 6.1).
+
+Definition 2. A function $G : \mathbb { C } \to \mathbb { C } ^ { N \times N }$ is strictly positive real if it satisfies the following:
+
+(i) The poles of $G ( s )$ have negative real parts.   
+(ii) $G ( i \omega ) + G ( - i \omega ) ^ { T }$ is positive definite for all $\omega \in \mathbb { R }$ , where $i = \sqrt { - 1 }$ .   
+(iii) Either $G ( \infty ) \ + \ G ( \infty ) ^ { T }$ is positive definite or it is positive semidefinite and $\begin{array} { r } { \operatorname* { l i m } _ { \omega  \infty } \omega ^ { 2 } M ^ { T } [ G ( i \omega ) _ { - } + G ( - i \omega ) ^ { T } ] M } \end{array}$ is positive definite for any $N \times ( N - q )$ full-rank matrix $M$ such that $M ^ { T } [ G ( \infty ) + \dot { G ( \infty ) } ^ { T } ] M = 0$ , where $q = \mathrm { r a n k } [ G ( \infty ) + G ( \infty ) ^ { T } ]$ .
+
+The following is presented in (Khalil, 2002, Lemma 6.3).
+
+Lemma 3 (Kalman-Yakubovich-Popov). Let $A , W : \mathbb { R } ^ { N } \to \mathbb { R } ^ { N }$ be full-rank square matrices. There exists a symmetric positive-definite matrix $P$ and matrices $L , U$ and a constant $\epsilon > 0$ such that
+
+$$
+\begin{array} { c } { { P A + A ^ { T } P = - L ^ { T } L - \epsilon P } } \\ { { } } \\ { { P = L ^ { T } U - W ^ { T } } } \\ { { } } \\ { { U ^ { T } U = 0 , } } \end{array}
+$$
+
+if and only if the transfer function $G ( s ) = { \cal W } ( s I - A ) ^ { - 1 }$ is strictly positive real. In this case, we may take $\epsilon = 2 \mu$ , where $\mu > 0$ is chosen so that $G ( s - \mu )$ remains strictly positive real.
+
+A shorter proof for case (a) is available to us through the (multivariable) circle criterion — the following theorem is a corollary of (Khalil, 2002, Theorem 7.1) suitable for our purposes.
+
+Theorem 3 (Circle Criterion). The system of differential equations
+
+$$
+\dot { h } = A h + \psi ( t , W h )
+$$
+
+is globally exponentially stable towards an equilibrium at the origin if $\| \psi ( t , y ) \| \le M \| y \|$ for some $M > 0$ and $Z ( s ) = [ I + M G ( s ) ] [ I - \overline { { { M G ( s ) } } } ] ^ { - 1 }$ is strictly positive real, where $G ( s ) =$ $W ( s I - A ) ^ { - 1 }$ .
+
+Both the Kalman-Yakubovich-Popov lemma and the circle criterion are classical results in control theory, and are typically discussed in the setting of feedback systems (Khalil, 2002, Chapter 6, 7). Our presentation here is less general than the complete formulation, but makes clearer the connection to RNNs. With these tools, we state our proof of Theorem 1.
+
+Proof of Theorem $^ { l }$ . To begin, we shall center the differential equation about the equilibrium. By assumption, there exists $h ^ { * }$ such that $A h ^ { * } = - \sigma ( W h ^ { * } + U x ( t ) + b )$ . Letting $\bar { h } = h ^ { ^ { \ast } } - h ^ { \ast }$ , we find that
+
+$$
+\begin{array} { r l } & { \dot { \bar { h } } = A h + \sigma ( W h + U x ( t ) + b ) } \\ & { \quad = A \bar { h } + A h ^ { * } + \sigma ( W \bar { h } + W h ^ { * } + U x ( t ) + b ) } \\ & { \quad = A \bar { h } + \sigma ( W h + W h ^ { * } + U x ( t ) + b ) - \sigma ( W h ^ { * } + U x ( t ) + b ) . } \end{array}
+$$
+
+It will suffice to show that (13) is globally exponentially stable at the origin.
+
+Let us begin with case (a). The proof follows arguments analogous to (Khalil, 2002, Example 7.1). Let $G ( s ) { \dot { = } } W ( A - s I ) ^ { - 1 }$ denote the transfer function for the system (13). Letting
+
+$$
+\psi ( t , x ) = \sigma ( x + W h ^ { \ast } + U x ( t ) + b ) - \sigma ( W h ^ { \ast } + U x ( t ) + b ) ,
+$$
+
+since $\sigma$ is $M$ -Lipschitz, we know that $\| \psi ( t , x ) \| \leq M \| x \|$ for any $\boldsymbol { x } \in \mathbb { R } ^ { N }$ . Therefore, let $Z ( s ) =$ $[ I + M G ( s ) ] [ \bar { I } - M G ( s ) ] ^ { - 1 }$ denote the transfer function in the circle criterion. Our objective is to show that $Z ( s )$ is strictly positive real — by Theorem 3, this will guarantee the desired global exponential stability of (4). First, we need to show that the poles of $Z ( s )$ have negative real parts. This can only occur when $G ( s )$ itself has poles or $I - M G ( s )$ is singular. The former case occurs precisely where $A - s I$ is singular, which occurs when $s$ is an eigenvalue of $A$ . Since $A + A ^ { T }$ is assumed to be negative definite, $A$ must have eigenvalues with negative real part by Lemma 4, and so the poles of $G ( s )$ also have negative real parts. The latter case is more difficult to treat. First, since $\bar { \sigma _ { \operatorname* { m a x } } } ( A B ) \leq \sigma _ { \operatorname* { m a x } } ( A ) \sigma _ { \operatorname* { m a x } } \bar { ( B ) }$ and $\dot { \sigma _ { \mathrm { m a x } } } ( B ^ { - 1 } ) = \sigma _ { \mathrm { m i n } } ( B ) ^ { - 1 }$ ,
+
+$$
+\sigma _ { \operatorname* { m a x } } ( G ( s ) ) \leq \frac { \sigma _ { \operatorname* { m a x } } ( W ) } { \sigma _ { \operatorname* { m i n } } ( A - s I ) } .
+$$
+
+Therefore, we observe that
+
+$$
+\begin{array} { r l r } & { } & { \sigma _ { \operatorname* { m i n } } ( I - M G ( s ) ) \geq 1 - \sigma _ { \operatorname* { m a x } } ( M G ( s ) ) } \\ & { } & { \geq 1 - M \sigma _ { \operatorname* { m a x } } ( G ( s ) ) } \\ & { } & { \geq 1 - \cfrac { M \sigma _ { \operatorname* { m a x } } ( W ) } { \sigma _ { \operatorname* { m i n } } ( A - s I ) } . } \end{array}
+$$
+
+From the Fan-Hoffman inequality (Bhatia, 2013, Proposition III.5.1), we have that
+
+$$
+\sigma _ { \operatorname* { m i n } } \bigl ( A - s I \bigr ) = \sigma _ { \operatorname* { m i n } } \bigl ( s I - A \bigr ) \geq \lambda _ { \operatorname* { m i n } } \left( \Re ( s ) I - \frac { A + A ^ { T } } { 2 } \right) = \Re ( s ) + \lambda _ { \operatorname* { m i n } } \left( - \frac { A + A ^ { T } } { 2 } \right) ,
+$$
+
+and since $A + A ^ { T }$ is negative definite, for any $s$ with $\Re ( s ) \geq 0$ ,
+
+$$
+\sigma _ { \operatorname* { m i n } } ( A - s I ) \geq \Re ( s ) + \sigma _ { \operatorname* { m i n } } \left( { \frac { A + A ^ { T } } { 2 } } \right) \geq \sigma _ { \operatorname* { m i n } } ( A ^ { \operatorname { s y m } } ) .
+$$
+
+Since $\sigma _ { \mathrm { m i n } } ( A ^ { \mathrm { s y m } } ) > M \sigma _ { \mathrm { m a x } } ( W )$ , it follows that $\sigma _ { \operatorname* { m i n } } ( I - M G ( s ) ) > 0$ whenever $s$ has nonnegative real part, and so the poles of $Z ( s )$ must have negative real parts.
+
+Next, we need to show that $Z ( i \omega ) + Z ( - i \omega ) ^ { T }$ is positive definite for all $\omega \in \mathbb { R }$ . Observe that
+
+$$
+\begin{array} { r l } & { Z ( i \omega ) + Z ( - i \omega ) ^ { T } = [ I + M G ( i \omega ) ] [ I - M G ( i \omega ) ] ^ { - 1 } + [ I - M G ( - i \omega ) ^ { T } ] ^ { - 1 } [ I + M G ( - i \omega ) ^ { T } ] } \\ & { \qquad = 2 [ I - M G ( - i \omega ) ^ { T } ] ^ { - 1 } [ I - M ^ { 2 } G ( - i \omega ) ^ { T } G ( i \omega ) ] [ I - M G ( i \omega ) ] ^ { - 1 } . } \end{array}
+$$
+
+From Sylvester’s law of inertia, we may infer that $Z ( i \omega ) + Z ( - i \omega ) ^ { T }$ is positive definite if and only if $I + Y _ { \omega }$ is positive definite, where $\begin{array} { r } { Y _ { \omega } = M ^ { 2 } G ( - i \dot { \omega } ) ^ { T } G ( i \omega ) } \end{array}$ . If we can show that the eigenvalues of $Y _ { \omega }$ lie strictly within the unit circle, that is, $\sigma _ { \operatorname* { m a x } } ( Y _ { \omega } ) < 1$ for all $\omega \in \mathbb { R }$ , then $I + Y _ { \omega }$ will necessarily be positive definite. From (14) and (15), we may verify that
+
+$$
+\operatorname* { s u p } _ { \omega \in \mathbb { R } } \sigma _ { \operatorname* { m a x } } ( G ( i \omega ) ) \leq \operatorname* { s u p } _ { \omega \in \mathbb { R } } \frac { \sigma _ { \operatorname* { m a x } } ( W ) } { \sigma _ { \operatorname* { m i n } } ( A - i \omega I ) } \leq \frac { \sigma _ { \operatorname* { m a x } } ( W ) } { \sigma _ { \operatorname* { m i n } } ( A ^ { \mathrm { s y m } } ) } .
+$$
+
+Therefore,
+
+$$
+\sigma _ { \operatorname* { m a x } } ( Y _ { \omega } ) \leq M ^ { 2 } \sigma _ { \operatorname* { m a x } } ( G ( - i \omega ) ^ { T } ) \sigma _ { \operatorname* { m a x } } ( G ( i \omega ) ) \leq \bigg ( \frac { M \sigma _ { \operatorname* { m a x } } ( W ) } { \sigma _ { \operatorname* { m i n } } ( A ^ { \mathrm { s y m } } ) } \bigg ) ^ { 2 } < 1 ,
+$$
+
+by assumption. Finally, since $Z ( \infty ) + Z ( \infty ) ^ { T } = 2 I$ is positive definite, $Z ( s )$ is strictly positive real and Theorem 3 applies.
+
+Now, consider case (b). The proof proceeds in two steps. First, we verify that the transfer function $G ( s ) = { \cal W } ( A - s I ) ^ { - 1 }$ satisfies the conditions of the Kalman-Yakubovich-Popov lemma. Then, using the matrices $P , L , U$ , and the constant $\epsilon$ inferred from the lemma, a Lyapunov function is constructed which satisfies the conditions of Theorem 2, guaranteeing global exponential stability. Once again, condition (i) of Lemma 3 is straightforward to verify: $G ( s )$ exhibits poles when $s$ is an eigenvalue of $A$ , and so the poles of $G ( s )$ also have negative real parts. Furthermore, condition (iii) is easily satisfied with $M = I$ since $\dot { G } ( \infty ) + G ( \infty ) ^ { \check { T } } = 0$ . To show that condition (ii) holds, observe that for any $\omega \in \mathbb { R }$ , letting $A ^ { - T } = ( A ^ { - 1 } ) ^ { T }$ for brevity,
+
+$$
+\begin{array} { r l } & { G ( i \omega ) + G ( - i \omega ) ^ { T } = W ( A - i \omega I ) ^ { - 1 } + ( A + i \omega I ) ^ { - T } W ^ { T } } \\ & { \qquad = ( A + i \omega I ) ^ { - T } [ ( A + i \omega I ) ^ { T } W + W ^ { T } ( A - i \omega I ) ] ( A - i \omega I ) ^ { - 1 } . } \end{array}
+$$
+
+Since the inner matrix factor is Hermitian, Sylvester’s law of inertia implies that $G ( i \omega ) + G ( - i \omega ) ^ { T }$ is positive definite if and only if
+
+$$
+B _ { \omega } : = ( A + i \omega I ) ^ { T } W + W ^ { T } ( A - i \omega I ) .
+$$
+
+is positive definite. Since $B _ { \omega }$ is a Hermitian matrix, it has real eigenvalues, with minimal eigenvalue given by the infimum of the Rayleigh quotient:
+
+$$
+\begin{array} { r l } & { \lambda _ { \operatorname* { m i n } } \big ( B _ { \omega } \big ) = \underset { \| v \| = 1 } { \operatorname* { i n f } } v ^ { T } B _ { \omega } v } \\ & { \quad \quad = \underset { \| v \| = 1 } { \operatorname* { i n f } } v ^ { T } ( A ^ { T } W + W ^ { T } A ) v + i \omega v ^ { T } ( W - W ^ { T } ) v } \\ & { \quad \quad = \underset { \| v \| = 1 } { \operatorname* { i n f } } v ^ { T } ( A ^ { T } W + W ^ { T } A ) v } \\ & { \quad \quad = \lambda _ { \operatorname* { m i n } } \big ( A ^ { T } W + W ^ { T } A \big ) . } \end{array}
+$$
+
+By assumption, $A ^ { T } W + W ^ { T } A$ has strictly positive eigenvalues, and hence $B _ { \omega }$ and $G ( i \omega ) +$ $\dot { G } ( - i \omega ) ^ { T }$ are positive definite. Therefore, Lemma 3 applies, and we obtain matrices $P , L , U$ and a constant $\epsilon > 0$ with the corresponding properties.
+
+Now we may construct our Lyapunov function $V$ . Let $v = W { \bar { h } }$ and
+
+$$
+u ( t ) = \sigma ( v ( t ) + W h ^ { \ast } + U x ( t ) + b ) - \sigma ( W h ^ { \ast } + U x ( t ) + b ) ,
+$$
+
+so that ${ \dot { \bar { h } } } = A { \bar { h } } + u$ . Since $\sigma$ is monotone non-decreasing, $\sigma ( x ) - \sigma ( y ) \geq 0$ for any $x \geq y$ . This implies that for each $i = 1 , \ldots , N ,$ $v _ { i }$ and $u _ { i }$ have the same sign. In particular, $v ^ { T } u \geq 0$ . Now, let $\dot { V ( h ) } = h ^ { T } P h$ be our Lyapunov function, noting that $V$ is independent of $t$ . Taking the derivative of the Lyapunov function over (13) and using the properties of $P , L , U , \epsilon$ ,
+
+$$
+\begin{array} { r l } & { \dot { V } ( \bar { h } ) = \bar { h } ^ { T } P \dot { \bar { h } } + \dot { \bar { h } } ^ { T } P \bar { h } } \\ & { \quad \quad = \bar { h } ^ { T } ( P A + A ^ { T } P ) \bar { h } + 2 \bar { h } ^ { T } P u } \\ & { \quad \quad = \bar { h } ^ { T } ( - L ^ { T } L - \epsilon P ) \bar { h } + 2 \bar { h } ^ { T } ( L ^ { T } U - W ^ { T } ) u } \\ & { \quad \quad = - ( L \bar { h } ) ^ { T } ( L \bar { h } ) + ( L \bar { h } ) ^ { T } U u + ( U u ) ^ { T } ( L \bar { h } ) - u ^ { T } U ^ { T } U u - 2 v ^ { T } u } \\ & { \quad \quad = - ( L \bar { h } + U u ) ^ { T } ( L \bar { h } + U u ) - \epsilon \bar { h } ^ { T } P \bar { h } - 2 v ^ { T } u . } \end{array}
+$$
+
+Since $v ^ { T } u \geq 0$ and $( L \bar { h } + U u ) ^ { T } ( L \bar { h } + U u ) \ge 0$ , it follows that $\dot { V } ( \bar { h } ) \leq - \epsilon \lambda _ { \operatorname* { m i n } } ( P ) \| h \| ^ { 2 }$ , and hence global exponential stability follows from Theorem 2 and positive-definiteness of $P$ . □
+
+To finish off discussion regarding the results from Sec. 3, we provide a quick proof of Lemma 1 using a simple diagonalization argument.
+
+Proof of Lemma $^ { l }$ . Since $A$ is symmetric and real-valued, by (Horn & Johnson, 2012, Theorem 4.1.5), there exists an orthogonal matrix $P$ and a real diagonal matrix $D$ such that $A = P D P ^ { T }$ . Letting $z = P ^ { T } h$ where $h$ satisfies (4), since $h = P z$ , we see that
+
+$$
+\begin{array} { r l } & { \dot { z } = P ^ { T } P D P ^ { T } h + P ^ { T } \sigma ( W h + U x + b ) } \\ & { \quad = D z + P ^ { T } \sigma ( W P z + U x + b ) . } \end{array}
+$$
+
+Therefore, $z$ satisfies (5) with $L = P ^ { T }$ and $V = W P$ , both of which are nonsingular by orthogonality of $P$ . By the same argument, for any equilibrium $h ^ { * }$ , taking $z ^ { * } = P ^ { T } h ^ { * }$ ,
+
+$$
+\begin{array} { r } { D z ^ { * } + P ^ { T } \sigma ( W P z ^ { * } + U x + b ) = P ^ { T } ( P D P ^ { T } h ^ { * } + \sigma ( W h ^ { * } + U x + b ) ) } \\ { = P ^ { T } ( A h ^ { * } + \sigma ( W h ^ { * } + U x + b ) ) = 0 , } \end{array}
+$$
+
+implying that $z ^ { * }$ is an equilibrium of (5). Furthermore, since
+
+$$
+\begin{array} { r l } & { \| \boldsymbol { z } - \boldsymbol { z } ^ { * } \| ^ { 2 } = ( P ^ { T } h - P ^ { T } h ^ { * } ) ^ { T } ( P ^ { T } h - P ^ { T } h ^ { * } ) } \\ & { \qquad = ( h - h ^ { * } ) ^ { T } P P ^ { T } ( h - h ^ { * } ) = \| h - h ^ { * } \| ^ { 2 } , } \end{array}
+$$
+
+from orthogonality of $P$ . Because every form of Lyapunov stability, both local and global, including global exponential stability, depend only on the norm $\| h - h ^ { * } \|$ (Khalil, 2002, Definitions 4.4 and 4.5), $h ^ { * }$ is stable under any of these forms if and only if $z ^ { * }$ is also stable. □
+
+We remark that the proof of Lemma 1 can extend to matrices $A$ which have real eigenvalues and are diagonalizable. These attributes are implied for symmetric matrices. However, they can be difficult to ensure in practice for nonsymmetric matrices without imposing difficult structural constraints.
+
+# A.2 PROOF OF PROPOSITION 1
+
+The proof of Proposition 1 relies on the following lemma, which we also have made use of several times throughout this work.
+
+Lemma 4. For any matrix $A \in \mathbb { R } ^ { N \times N }$ , the real parts of the eigenvalues $\Re \lambda _ { i } ( A )$ are contained in the interval $[ \lambda _ { \operatorname* { m i n } } ( A ^ { \mathrm { s y m } } ) , \lambda _ { \operatorname* { m a x } } ( A ^ { \mathrm { s y m } } ) ]$ , where $\begin{array} { r } { A ^ { \mathrm { { { s y m } } } } = \frac { 1 } { 2 } ( A + \mathbf { \bar { { A } } } ^ { T } ) } \end{array}$ .
+
+Proof. Recall by the min-max theorem, for $\langle u , v \rangle = u ^ { \ast } v$ , where $u ^ { * }$ is the conjugate transpose of $u$ , the upper and lower eigenvalues of $A + A ^ { T }$ satisfy
+
+$$
+\begin{array} { r l } & { \lambda _ { \operatorname* { m i n } } ( A + A ^ { T } ) = \underset { v \in \mathbb { C } ^ { N } , \| v \| = 1 } { \operatorname* { i n f } } \langle v , ( A + A ^ { T } ) v \rangle = \underset { v \in \mathbb { C } ^ { N } , \| v \| = 1 } { \operatorname* { i n f } } \langle v , A v \rangle + \langle A v , v \rangle , } \\ & { \lambda _ { \operatorname* { m a x } } ( A + A ^ { T } ) = \underset { v \in \mathbb { C } ^ { N } , \| v \| = 1 } { \operatorname* { s u p } } \langle v , ( A + A ^ { T } ) v \rangle = \underset { v \in \mathbb { C } ^ { N } , \| v \| = 1 } { \operatorname* { s u p } } \langle v , A v \rangle + \langle A v , v \rangle . } \end{array}
+$$
+
+Let $\lambda _ { i } ( A ) = u + i \omega$ be an eigenvalue of $A$ with corresponding eigenvector $v$ satisfying $\lVert \boldsymbol { v } \rVert = 1$ . Since $\overset { \triangledown } { A \boldsymbol { v } } = ( u + i \omega ) \boldsymbol { v }$ ,
+
+$$
+\langle v , A v \rangle + \langle A v , v \rangle = \langle v , A v \rangle + { \overline { { \langle v , A v \rangle } } } = 2 \Re \langle v , A v \rangle = 2 u \| v \| ^ { 2 } = 2 u .
+$$
+
+Hence, $\lambda _ { \operatorname* { m i n } } ( A + A ^ { T } ) \leq u \leq \lambda _ { \operatorname* { m a x } } ( A + A ^ { T } )$ .
+
+Proof of Proposition $^ { l }$ . By construction, $S _ { \beta , \gamma } ^ { \mathrm { s y m } } = S _ { \beta , \gamma } + S _ { \beta , \gamma } ^ { T } = ( 1 - \beta ) M ^ { \mathrm { s y m } } - \gamma I$ , and so from Lemma 4, both the real parts $S _ { \beta , \gamma } ^ { \mathrm { s y m } }$ lie in the interval $\Re \lambda _ { i } ( S _ { \beta , \gamma } )$ of the eigenvalues of $S _ { \beta , \gamma }$ as well as the eigenvalues of
+
+$$
+[ \lambda _ { \operatorname* { m i n } } ( S _ { \beta , \gamma } ^ { \mathrm { s y m } } ) , \lambda _ { \operatorname* { m a x } } ( S _ { \beta , \gamma } ^ { \mathrm { s y m } } ) ] = [ \lambda _ { \operatorname* { m i n } } ( ( 1 - \beta ) M ^ { \mathrm { s y m } } - \gamma I ) , \lambda _ { \operatorname* { m a x } } ( ( 1 - \beta ) M ^ { \mathrm { s y m } } - \gamma I ) ] .
+$$
+
+If $\beta < 1$ , for any eigenvalue $\lambda$ of $S _ { \beta , \gamma } ^ { \mathrm { s y m } }$ with corresponding eigenvector $v$ ,
+
+$$
+( 1 - \beta ) M ^ { \mathrm { s y m } } v - \gamma v = \lambda v , \quad \mathrm { a n d \ s o } \quad M ^ { \mathrm { s y m } } v = \frac { \lambda + \gamma } { 1 - \beta } v
+$$
+
+implying that $\frac { \lambda + \gamma } { 1 - \beta }$ is an eigenvalue of $M ^ { \mathrm { s y m } }$ , and therefore contained in $[ \lambda _ { \operatorname* { m i n } } ( M ^ { \mathrm { s y m } } ) , \lambda _ { \operatorname* { m a x } } ( \dot { M } ^ { \mathrm { s y m } } ) ]$ . In particular, we find that
+
+$$
+\begin{array} { r } { [ \lambda _ { \operatorname* { m i n } } ( S _ { \beta , \gamma } ^ { \mathrm { s y m } } ) , \lambda _ { \operatorname* { m a x } } ( S _ { \beta , \gamma } ^ { \mathrm { s y m } } ) ] \subseteq [ ( 1 - \beta ) \lambda _ { \operatorname* { m i n } } ( M ^ { \mathrm { s y m } } ) - \gamma , ( 1 - \beta ) \lambda _ { \operatorname* { m a x } } ( M ^ { \mathrm { s y m } } ) ] , } \end{array}
+$$
+
+as required. Finally, if $\beta = 1$ , then (16) still holds, since both intervals collapse to the single point $\{ - \gamma \}$ . □
+
+![](images/a7884ca8370ace6ab3945de4e5d6d4a4e78821d7016896082d9ab3b5e365bbb9.jpg)  
+Figure 4: Empirical evaluation of the theoretical bounds (16). The red lines track the largest real part and the blue lines track the smallest real part of the eigenvalues of the hidden-to-hidden matrix $A _ { \beta }$ . Each line corresponds to a different hidden-to-hidden matrix of dimension $N = 6 4$ in (a) and $N = 1 2 8$ in (b). The dashed black lines indicate the theoretical bound for each trial.
+
+Figure 4 illustrates the effect of $\beta$ onto the eigenvalues of $A _ { \beta , \gamma }$ with the largest and smallest real parts. It can be seen, both empirically and theoretically, that the real part of the eigenvalues converges towards zero as $\beta$ tends towards one, i.e., we yield a skew-symmetric matrix with purely imaginary eigenvalues in the limit. Thus, for a sufficiently large parameter $\beta$ we yield a system that approximately preserves an “energy” for a limited time-horizon
+
+$$
+\mathcal { R } \lambda _ { i } ( A _ { \beta , \gamma } ) \approx 0 , \quad \mathrm { f o r } \quad i = 1 , 2 , \ldots , N .
+$$
+
+# A.3 PROOF OF LEMMA 2
+
+First, it follows from Gronwall’s inequality that the norm of the final hidden state $\| h ( T ) \|$ is bounded uniformly in $\beta$ . From Weyl’s inequalities and the definition of $A _ { \beta , \gamma }$ ,
+
+$$
+\operatorname* { m a x } _ { k } | \Delta _ { \delta } \lambda _ { k } ( A _ { \beta , \gamma } ^ { \mathrm { s y m } } ) | \leq \| \Delta _ { \delta } A _ { \beta , \gamma } ^ { \mathrm { s y m } } \| = ( 1 - \beta ) \| \Delta _ { \delta } M _ { A } ^ { \mathrm { s y m } } \| .
+$$
+
+By the chain rule, for each element $M _ { A } ^ { i j }$ of the matrix $M _ { A }$
+
+$$
+\frac { \partial L } { \partial M _ { A } ^ { i j } } = \frac { \partial L } { \partial y ( T ) } \frac { \partial y ( T ) } { \partial h ( T ) } \frac { \partial h ( T ) } { \partial M _ { A } ^ { i j } } = \frac { \partial L } { \partial y ( T ) } D \frac { \partial h ( T ) } { \partial M _ { A } ^ { i j } } .
+$$
+
+Now, for any collection of parameters $\theta _ { i }$ ,
+
+$$
+\frac { d } { d t } \sum _ { i } \frac { \partial h } { \partial \theta _ { i } } = A \sum _ { i } \frac { \partial h } { \partial \theta _ { i } } + \sum _ { i } \frac { \partial A } { \partial \theta _ { i } } h + \mathrm { s e c h } ^ { 2 } \left( W h + U x + b \right) \left( W \sum _ { i } \frac { \partial h } { \partial \theta _ { i } } + \sum _ { i } \frac { \partial W } { \partial \theta _ { i } } h \right) ,
+$$
+
+and from Gronwall’s inequality,
+
+$$
+\begin{array} { r l } { \displaystyle \left\| \sum _ { i } \frac { \partial h ( T ) } { \partial \theta _ { i } } \right\| \leq \left( \left\| \sum _ { i } \frac { \partial A _ { \beta , \gamma } } { \partial \theta _ { i } } \right\| + \left\| \sum _ { i } \frac { \partial W _ { \beta , \gamma } } { \partial \theta _ { i } } \right\| \right) \| h \| e ^ { \| ( A _ { \beta , \gamma } \| + \| W _ { \partial , \tau } \| ) T } . } & { } \\ { \displaystyle \lambda _ { \delta } \mathcal { M } _ { A } ^ { \operatorname* { s u p } } = \delta \frac { \partial L } { \partial \theta _ { i } } + \delta \left( \frac { \partial L } { \partial M _ { A } } \right) ^ { T } , } & { } \\ { \| \Delta _ { \delta } \mathcal { M } _ { A } ^ { \operatorname* { s u p } } \| \leq \| \Delta _ { \delta } \mathcal { M } _ { A } ^ { \operatorname* { s u p } } \| _ { F } } \\ { \leq \delta \sqrt { \displaystyle \sum _ { i , j } \left( \frac { \partial L } { \partial \mathcal { M } _ { A } ^ { \delta } } + \frac { \partial L } { \partial \mathcal { M } _ { A } ^ { \delta } } \right) ^ { 2 } } } & { } \\ { \leq \delta \left\| \frac { \partial L } { \partial y } \right\| \| D \| \| h \| \epsilon ^ { ( \| A _ { \delta , \gamma } \| + \| W _ { \delta , \tau } \| ) T } \sqrt { \displaystyle \sum _ { i , j } \left\| \frac { \partial A \partial _ { \beta , \gamma } } { \partial M _ { A } ^ { \frac { \delta } { \delta } } } + \frac { \partial A _ { \beta , \gamma } } { \partial M _ { \delta } ^ { \frac { \delta } { \delta } } } \right\| ^ { 2 } } . } & { } \end{array}
+$$
+
+Since $\begin{array} { r } { \frac { \partial ( M _ { A } h ) } { \partial M _ { A } ^ { i j } } = \frac { \partial ( M _ { A } ^ { T } h ) } { \partial M _ { A } ^ { j i } } } \end{array}$ ∂(M TA h)ji , it follows that
+
+$$
+\frac { \partial A _ { \beta , \gamma } } { \partial M _ { A } ^ { i j } } + \frac { \partial A _ { \beta , \gamma } } { \partial M _ { A } ^ { j i } } = 2 ( 1 - \beta ) \left( \frac { \partial ( M _ { A } h ) } { \partial M _ { A } ^ { i j } } + \frac { \partial ( M _ { A } ^ { T } h ) } { \partial M _ { A } ^ { j i } } \right) ,
+$$
+
+and so $\lVert \Delta _ { \delta } M _ { A } ^ { \mathrm { s y m } } \rVert = \mathcal { O } ( \delta ( 1 - \beta ) )$ , and therefore $\begin{array} { r } { \operatorname* { m a x } _ { k } | \Delta _ { \delta } \sigma _ { k } ( A _ { \beta , \gamma } ^ { \mathrm { s y m } } ) | = \mathcal { O } ( \delta ( 1 - \beta ) ^ { 2 } ) } \end{array}$ . Similarly, for the matrix $M _ { W }$ ,
+
+$$
+\begin{array} { l } { \displaystyle \operatorname* { m a x } _ { k } \Big | \Delta _ { \delta } \lambda _ { k } ( W _ { \beta , \gamma } ^ { \mathrm { s y m } } ) \Big | \leq ( 1 - \beta ) \| \Delta _ { \delta } M _ { W } ^ { \mathrm { s y m } } \| } \\ { \leq \delta ( 1 - \beta ) \left\| \frac { \partial L } { \partial y } \right\| \| D \| \| h \| e ^ { ( \| A _ { \beta , \gamma } \| + \| W _ { \beta , \gamma } \| ) T } \sqrt { \displaystyle \sum _ { i , j } \left\| \frac { \partial W _ { \beta , \gamma } } { \partial M _ { W } ^ { i j } } + \frac { \partial W _ { \beta , \gamma } } { \partial M _ { W } ^ { j i } } \right\| ^ { 2 } } } \\ { = 2 \delta ( 1 - \beta ) ^ { 2 } \left\| \frac { \partial L } { \partial y } \right\| \| D \| \| h \| e ^ { ( \| A _ { \beta , \gamma } \| + \| W _ { \beta , \gamma } \| ) T } \sqrt { \displaystyle \sum _ { i , j } \left( \frac { \partial ( M _ { W } h ) } { \partial M _ { W } ^ { i j } } + \frac { \partial ( M _ { W } ^ { T } h ) } { \partial M _ { W } ^ { j i } } \right) ^ { 2 } } , } \end{array}
+$$
+
+and hence $\begin{array} { r } { \operatorname* { m a x } _ { k } | \Delta _ { \delta } \lambda _ { k } ( W _ { \beta , \gamma } ^ { \mathrm { s y m } } ) | = \mathcal { O } ( \delta ( 1 - \beta ) ^ { 2 } ) } \end{array}$ .
+
+In Figure 5, we plot the most positive real part of the eigenvalues of $A _ { \beta , \gamma }$ and $W _ { \beta , \gamma }$ during training for the ordered MNIST task. As $\beta$ increases, the eigenvalues change less during training, remaining in the stability region provided by case (b) of Theorem 1 for more of the training time.
+
+![](images/75d272f9a547d4af1a10cebbe28f026379b992e2c521b99683b532e1ffccda07.jpg)  
+Figure 5: The red lines track the largest real part of the eigenvalues of the hidden-to-hidden matrix $A _ { \beta , \gamma }$ and the blue lines track the largest real part of the eigenvalues of $W _ { \beta , \gamma }$ . We show results for two models trained on the ordered MNIST task with varying $\beta$ .
+
+# B ADDITIONAL EXPERIMENTS
+
+# B.1 SENSITIVITY TO RANDOM INITIALIZATION FOR MNIST AND TIMIT
+
+The hidden matrices are initialized by sampling weights from the normal distribution $\mathcal { N } ( 0 , \sigma )$ , where $\sigma$ is the variance, which can be treated as a tuning parameter. In our experiments we typically chose a small $\sigma$ ; see the Table 8 for details. To show that the Lipschitz RNN is insensitive to random initialization, we have trained each model with 10 different seeds. Table 4 shows the maximum, average and minimum values obtained for each task. Note that higher values indicate better performance on the ordered and permuted MNIST tasks, while lower values indicate better performance on the TIMIT task.
+
+# B.2 ORDERED PIXEL-BY-PIXEL AND NOISE-PADDED CIFAR-10
+
+The pixel-by-pixel CIFAR-10 benchmark problem that has recently been proposed by (Chang et al., 2019). This task is similar to the pixel-by-pixel MNIST task, yet more challenging due to the increased sequence length and the more difficult classification problem. Similar to MNIST, we flatten the CIFAR-10 images to construct a sequence of length 1024 in scanline order, where each element of the sequence consists of three pixels (one from each channel).
+
+A variation of this problem is the noise-padded CIFAR-10 problem (Chang et al., 2019), where we consider each row of an image as input at time step $t$ . The rows from each channel are stacked so that we obtain an input of dimension $x \in \mathbb { R } ^ { 9 6 }$ . Then, after the 32 time step which process the 32 row, we start to feed the recurrent unit with independent standard Gaussian noise for 968 time steps. At the final point in $T = 1 0 0 0$ , we use the learned hidden state for classification. This problem is challenging because only the first 32 time steps contain signals. Thus, the recurrent unit needs to recall information from the beginning of the process.
+
+Table 4: Sensitivity to random initialization evaluated over 10 runs.   
+
+<table><tr><td>Solver</td><td>Task</td><td>Minimum</td><td>Average</td><td>Maximum</td><td>N</td><td># params</td></tr><tr><td>Euler</td><td>ordered MNIST</td><td>98.9%</td><td>99.0%</td><td>99.0%</td><td>64</td><td>~9K</td></tr><tr><td>RK2</td><td>ordered MNIST</td><td>98.9%</td><td>99.0%</td><td>99.1%</td><td>64</td><td>~9K</td></tr><tr><td>Euler</td><td>orderedMNIST</td><td>99.0%</td><td>99.2%</td><td>99.4%</td><td>128</td><td>~34K</td></tr><tr><td>RK2</td><td>ordered MNIST</td><td>98.9%</td><td>99.1%</td><td>99.3%</td><td>128</td><td>~34K</td></tr><tr><td>Euler</td><td>permuted MNIST</td><td>93.5%</td><td>93.8%</td><td>94.2%</td><td>64</td><td>~9K</td></tr><tr><td>RK2</td><td>permuted MNIST</td><td>93.5%</td><td>93.9%</td><td>94.2%</td><td>64</td><td>~9K</td></tr><tr><td>Euler</td><td>permuted MNIST</td><td>95.6%</td><td>95.9%</td><td>96.3%</td><td>128</td><td>~34K</td></tr><tr><td>RK2</td><td>permuted MNIST</td><td>95.4%</td><td>95.8%</td><td>96.2%</td><td>128</td><td>~34K</td></tr><tr><td>Euler</td><td>TIMIT (test MSE)</td><td>2.82</td><td>2.98</td><td>3.10</td><td>256</td><td>~198K</td></tr><tr><td>RK2</td><td>TIMIT (test MSE)</td><td>2.76</td><td>2.81</td><td>2.84</td><td>256</td><td>~198K</td></tr></table>
+
+Table 5: Evaluation accuracy on pixel-by-pixel CIFAR-10 and noise padded CIFAR-10.   
+
+<table><tr><td>Name</td><td>ordered</td><td>noise padded</td><td>N</td><td># params</td></tr><tr><td>LSTM baseline by (Chang et al.,2019)</td><td>59.7%</td><td>11.6%</td><td>128</td><td>69K</td></tr><tr><td>Antisymmetric RNN (Chang et al., 2019)</td><td>58.7%</td><td>48.3%</td><td>256</td><td>36K</td></tr><tr><td>Incremental RNN (Kag et al.,2020)</td><td>-</td><td>54.5%</td><td>128</td><td>1</td></tr><tr><td>Lipschitz RNN using Euler (ours)</td><td>60.5%</td><td>57.4%</td><td>128</td><td>34K/46K</td></tr><tr><td>Lipschitz RNN using RK2 (ours)</td><td>60.3%</td><td>57.3%</td><td>128</td><td>34K/46K</td></tr><tr><td>Lipschitz RNN using Euler (ours)</td><td>64.2%</td><td>59.0%</td><td>256</td><td>134K/158K</td></tr><tr><td>Lipschitz RNN using RK2 (ours)</td><td>64.2%</td><td>58.9%</td><td>256</td><td>134K/158K</td></tr></table>
+
+Table 5 provides a summary of our results. Our Lipschitz recurrent unit outperforms both the incremental RNN (Kag et al., 2020) and the antisymmetric RNN (Chang et al., 2019) by a significant margin. This impressively demonstrates that the Lipschitz unit enables the stable propagation of signals over long time horizons.
+
+# B.3 PENN TREE BANK (PTB)
+
+# B.3.1 CHARACTER LEVEL PREDICTION
+
+Next, we consider a character level language modeling task using the Penn Treebank Corpus (PTB) (Marcus et al., 1993). Specifically, this task studies how well a model can predict the next character in a sequence of text. The dataset is composed of a train / validation / test set, where 5017K characters are used for training, 393K characters are used for validation and 442K characters are used for testing. For our experiments, we used the publicly available implementation of this task by Kerg et al. (2019), which computes the performance in terms of mean bits per character (BPC).
+
+Table 6 shows the results for back-propagation through time (BPTT) over 150 and 300 time steps, respectively. The Lipschitz RNN performs slightly better then the exponential RNN and the nonnormal RNN on this task. (Kerg et al., 2019) notes that orthogonal hidden-to-hidden matrices are not particular well-suited for this task. Thus, it is not surprising that the Lipschitz unit has a small advantage here.
+
+For comparison, we have also tested the Antisymmetric RNN (Chang et al., 2019) on this task. The performance of this unit is considerably weaker as compared to our Lipschitz unit. This suggests that the Lipschitz RNN is more expressive and improves the propagation of meaningful signals over longer time scales.
+
+Table 6: Evaluation accuracy on PTB for character-level prediction for different sequence lengths $T$ . The \* indicate results that were adopted from Kerg et al. (2019).   
+
+<table><tr><td>Name</td><td>TPTB=150</td><td>TPTB = 300</td><td># params</td></tr><tr><td>RNN baseline by (Arjovsky et al., 2016)</td><td>2.89</td><td>2.90</td><td>~1.32M</td></tr><tr><td>RNN-orth (Henaff et al.,2016) (*)</td><td>1.62</td><td>1.66</td><td>~1.32M</td></tr><tr><td>EURNN (Jing et al.,2017) (*)</td><td>1.61</td><td>1.62</td><td>~1.32M</td></tr><tr><td>Exponential RNN (Lezcano-Casado &amp; Martinez-Rubio,2019)(*)</td><td>1.49</td><td>1.52</td><td>~1.32M</td></tr><tr><td>Non-normal RNN (Kerg et al.,2019)</td><td>1.47</td><td>1.49</td><td>~1.32M</td></tr><tr><td>Antisymmteric RNN</td><td>1.60</td><td>1.64</td><td>~1.32M</td></tr><tr><td>Lipschitz RNN using Euler (ours)</td><td>1.43</td><td>1.46</td><td>~1.32M</td></tr></table>
+
+# B.3.2 WORD-LEVEL PREDICTION
+
+In addition to character-level prediction, we also consider word-level prediction using the PTB corpus. For comparison with other state-of-the-art units, we consider the setup by Kusupati et al. (2018), who use a sequence length of 300. Table 7 shows results for back-propagation through time (BPTT) over 300 time steps. The Lipschitz RNN performs slightly better than the other RNNs on this task and the baseline LSTM for the test perplexity metric reported by Kusupati et al. (2018).
+
+Table 7: Evaluation accuracy on PTB for word-level prediction. The \* indicate results adopted from Kusupati et al. (2018). Note that here the parameters for the hidden-to-hidden units are reported.   
+
+<table><tr><td>Name</td><td>validation perplexity</td><td>test perplexity</td><td>N</td><td># params</td></tr><tr><td>LSTM(*)</td><td></td><td>117.41</td><td>=</td><td>210K</td></tr><tr><td>SpectraiRNN (*)</td><td></td><td>130.20</td><td></td><td>24.8K</td></tr><tr><td>FastRNN(*)</td><td></td><td>127.76</td><td>=</td><td>52.5K</td></tr><tr><td>FastGRNN-LSQ(*)</td><td></td><td>115.92</td><td>=</td><td>52.5K</td></tr><tr><td>FastGRNN (*)</td><td></td><td>116.11</td><td>=</td><td>52.5K</td></tr><tr><td>Incremental RNN (Kag et al.,2020)</td><td></td><td>115.71</td><td>=</td><td>29.5K</td></tr><tr><td>Lipschitz RNN using Euler (ours)</td><td>124.55</td><td>115.36</td><td>160</td><td>50K</td></tr></table>
+
+# C TUNING PARAMETERS
+
+For tuning we utilized a standard training procedure using a non-exhaustive random search within the following plausible ranges for the our weight parameterization $\beta = 0 . 6 5 , 0 . 7 , 0 . 7 5 , 0 . 8 ,$ $\gamma =$ [0.001, 1.0]. For Adam we explored learning rates between 0.001 and 0.005, and for SGD we considered 0.1. For the step size we explored values in the range 0.001 to 1.0. We did not perform an automated grid search and thus expect that the models can be further fine-tuned.
+
+The tuning parameters for the different tasks that we have considered are summarized in Table 8.
+
+For pixel-by-pixel MNIST and CIFAR-10, we use Adam for minimizing the objective. We train all our models for 100 epochs, with scheduled learning rate decays at epochs $\{ 9 0 \}$ . We do not use gradient clipping during training. Figure 6 shows the test accuracy curves for our Lipschitz RNN for the ordered and permuted MNIST classification tasks.
+
+For TIMIT we use Adam with default parameters for minimizing the objective. We also tried Adam using betas (0.0, 0.9) as well as RMSprop with $\alpha = 0 . 9$ , however, Adam with default values worked best in our experiments. We train the model for 1200 epochs without learning-rate decay. Similar to Kerg et al. (2019) we train our model with gradient clipping, however, we observed that the performance of our model is relatively insensitive to the clipping value.
+
+For the character level prediction task, we use Adam with default parameters for minimizing the objective, while we use RMSprop with $\alpha = 0 . 9$ for the word level prediction task. We train the model for 200 epochs for the character-level task, and for 500 epochs for the word-level task.
+
+Table 8: Tuning parameters used for our experimental results and the performance evaluated with 12 different seed values for the parameter initialization of the model.   
+
+<table><tr><td>Name</td><td>N</td><td>lr</td><td>decay</td><td>β</td><td>7a</td><td>2w</td><td>E</td><td>0</td></tr><tr><td>Ordered MNIST</td><td>64</td><td>0.003</td><td>0.1</td><td>0.75</td><td>0.001</td><td>0.001</td><td>0.03</td><td>0.1/64</td></tr><tr><td>Ordered MNIST</td><td>128</td><td>0.003</td><td>0.1</td><td>0.75</td><td>0.001</td><td>0.001</td><td>0.03</td><td>0.1/128</td></tr><tr><td>Permuted MNIST</td><td>64</td><td>0.0035</td><td>0.1</td><td>0.75</td><td>0.001</td><td>0.001</td><td>0.03</td><td>0.1/128</td></tr><tr><td>Permuted MNIST</td><td>128</td><td>0.0035</td><td>0.1</td><td>0.75</td><td>0.001</td><td>0.001</td><td>0.03</td><td>0.1/128</td></tr><tr><td>Ordered CIFAR10</td><td>256</td><td>0.1</td><td>0.2</td><td>0.65</td><td>0.001</td><td>0.001</td><td>0.01</td><td>6/256</td></tr><tr><td>Noise-padded CIFAR10</td><td>256</td><td>0.1</td><td>0.2</td><td>0.75</td><td>0.001</td><td>0.001</td><td>0.01</td><td>6/256</td></tr><tr><td>TIMIT</td><td>256</td><td>0.001</td><td>-</td><td>0.8</td><td>0.8</td><td>0.001</td><td>0.9</td><td>12/256</td></tr><tr><td>PTB character-level 150</td><td>750</td><td>0.005</td><td>-</td><td>0.8</td><td>0.5</td><td>0.001</td><td>0.1</td><td>12/256</td></tr><tr><td>PTB character-level 300</td><td>750</td><td>0.005</td><td>=</td><td>0.8</td><td>0.5</td><td>0.001</td><td>0.1</td><td>12/256</td></tr><tr><td>PTB word-level</td><td>160</td><td>0.1</td><td>-</td><td>0.8</td><td>0.9</td><td>0.001</td><td>0.01</td><td>10/256</td></tr></table>
+
+![](images/fb584eaa4dac2ff52ec3c7783e1c0f4d8edce39c0a971edf724798f18704971a.jpg)  
+Figure 6: Test accuracy for the Lipschitz RNN for different classification tasks.

parse/train/3X8qZL4_WO/3X8qZL4_WO.md

@@ -0,0 +1,464 @@
+# Mimicking Evolution with Reinforcement Learning
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+1 In nature, there are two processes driving the development of the brain: evolution   
+2 and learning. Evolution acts slowly, across generations, and amongst other things,   
+3 it defines what agents learn by changing their internal reward function. Learning   
+4 acts fast, within one’s lifetime, and it quickly updates agents’ policies to maximise   
+5 the evolved reward function. Although previous work has emulated both of these   
+6 processes working in tandem, the optimisation of the reward function in order to   
+7 serve the aims of the evolutionary process is very computationally expensive. This   
+8 work proposes a fixed reward function, the evolutionary reward, that aims to max  
+9 imise the number of current (and future) genetically similar agents. Furthermore,   
+10 we propose a way to approximate the joint action value by averaging the action   
+11 values of other agents weighted by their genetic similarity. In a finite environment   
+12 with limited resources this techniques drives improved survival mechanisms and   
+13 reproductive success. Given that this reward function is fixed, we avoid the com  
+14 putationally intense process of optimising it. We demonstrate the viability of our   
+15 evolutionary reward by testing it in two bio-inspired, open-ended environments and   
+16 monitoring a number of metrics such as population size and life expectancy. We   
+17 compare our technique with the state-of-the-art evolutionary algorithm: CMA-ES,   
+18 and show the superiority of work at producing agents that maximise the number of   
+19 its genes across time.
+
+# 20 1 Introduction
+
+21 Evolution is the only process we know of today that has given rise to general intelligence (as demon  
+22 strated in animals, and specifically in humans). This fact has been inspiring artificial intelligence (AI)   
+23 researchers to run evolution in artificial worlds that mimic key properties of life on Earth. One of   
+24 these key properties is open-endedness. This means that, as in nature, the fitness function (or any   
+25 goal function) of the environment is not defined anywhere but it simply emerges from the survival   
+26 and reproduction of genes. For this reason, we call these environments open-ended evolutionary   
+27 environments (OEEE). They are never-ending environments where adaptable agents are competing   
+28 for a common limited-resource to survive and replicate their genes. Using them for research is the   
+29 focus of the field of artificial life (ALife).   
+30 Our ability to run evolution efficiently in OEEE will dictate the success of ALife. In this work   
+31 we speed up the way evolution is ran in OEEE by introducing Evolution via Evolutionary Reward   
+32 (EvER). In EvER, each agent is born with an evolutionary reward that, when maximised by a learning,   
+33 it also maximises the survival and reproduction of the agent’s genes. Due to this property we say that   
+34 this reward is aligned with evolution. This allows learning to search for policies with increasingly   
+35 evolutionary fitness. Also, by guarantying this alignment we don’t need to go through the expensive   
+36 process of aligning the agents’ reward functions through evolution. This reward function was designed   
+37 to work on any OEEE.   
+38 In the remaining part of this introduction we 1) describe how evolution changes what we learn;   
+39 2) introduce our contribution and describe how maximising a reward function can lead to the   
+40 maximisation of evolutionary fitness.
+
+# 41 1.1 Evolving what to learn
+
+42 In nature, there are two different mechanisms driving the development of the brain. Evolution acts   
+43 slowly, across generations, and amongst other things, it defines what agents learn by changing their   
+44 internal reward function. Learning acts fast, within one’s lifetime, and it quickly updates agents’   
+45 policies to maximise pleasure and minimise pain. Combining these two methods has a long history   
+46 in AI research [1, 42, 8]. This combination (illustrated in Appendix B, Figure 3) results in a very   
+47 computationally expensive algorithm as it requires two loops 1) learning (the inner loop) where   
+48 agents maximise their innate reward functions across their lifetimes and 2) evolution (the outer loop)   
+49 where natural selection and mutation defines the reward functions for the next generation (amongst   
+50 other things, such as NN topologies and initial weights).   
+51 We say that a reward function is aligned with evolution when the maximisation of the reward leads   
+52 to the maximisation of the agent’s fitness. Through evolution the most aligned reward functions   
+53 get selected and increase their numbers. Intuitively, one can define the optimally aligned reward   
+54 function as the reward function that allows a learner to learn most quickly how to maximise its fitness,   
+55 assuming the conditions of the world (including other agents) remain the same. However, as agents   
+56 evolve and learn, they change their environment and its corresponding fitness function. This change,   
+57 increases the misalignment between the reward and fitness functions. Therefore, the optimally aligned   
+58 reward function is always chasing the ever changing fitness function (see Appendix C for a formal   
+59 description of this). However, in this paper, we show that in simulation it is possible to define a fixed   
+60 reward function which is always aligned, although not guaranteed to be optimally aligned, with the   
+61 essence of fitness: the ability of the individual to survive and reproduce its genes.   
+62 Our work allows learning to single-handedly drive the search for policies with increasingly evolution  
+63 ary fitness by ensuring the alignment of the reward function with the fitness function. This greatly   
+64 simplifies the two-loop algorithm used to combine evolution and learning that was described earlier in   
+65 this section. We can do this because our reward is extrinsic to the agent and therefore, only possible   
+66 within a simulation.
+
+# 67 1.2 Learning to maximise evolutionary fitness
+
+68 The distinction between an agent and a gene is key to understanding this paper. Formally, evolution is   
+69 a change in gene frequencies in a population (of agents) over time. The gene is the unit of evolution,   
+70 and an agent carries one or more genes. Richard Dawkins has famously described our bodies as   
+71 throwaway survival machines built for replicating immortal genes [6]. His line illustrates well the   
+72 gene-centered view of evolution [43, 6], a view that has been able to explain multiple phenomena   
+73 such as intragenomic conflict and altruism that are difficult to explain with organism-centered or   
+74 group-centered viewpoints [2, 10, 7]. From the gene’s perspective, the evolutionary process is a   
+75 constant competition for resources. However, from the agent’s perspective, the evolutionary process   
+76 is a mix between a cooperative exercise with agents that carry some of its genes (its family) and   
+77 a competition with unrelated agents. Evolution pressures agents to engage in various degrees of   
+78 collaboration depending on the degree of kinship between them and the agents they interact with (i.e.   
+79 depending on the amount of overlap between the genes they carry). This pressure for cooperation   
+80 amongst relatives was named kin selection [34].   
+81 Evolution acts on the gene level, but RL acts on the agent level. RL can be aligned with the   
+82 evolutionary process by noting what evolution does to the agents through its selection of genes:   
+83 evolution generates agents with increasing capabilities to maximise the survival and reproduction   
+84 success of the genes they carry.
+
+# 2 Related work
+
+86 Combining evolution and learning Combining evolution and learning has long history in AI   
+87 research. The evolutionary reinforcement learning algorithm, introduced in 1991 [1], makes the   
+88 evolutionary process determine the initial weights of two neural networks: an action and an evaluation   
+89 network. During an agent’s lifetime, learning adapts the action network guided by the output of   
+90 its innate and fixed (during its lifetime) evaluation network. $\mathrm { N E A T + Q }$ [42] uses an evolutionary   
+91 algorithm, NEAT [36], to evolve topologies of NN and their initial weights so that they can better   
+92 learn using RL. In NEAT-Q the reward function remains fixed. However, evolutionary algorithms   
+93 have also been used to evolve potential-based shaping rewards and meta-parameters for RL [8].   
+94 Competing in Arms-race Every time adaptable entities compete against each other an arms-race   
+95 is created. Each entity’s task gets harder every time their competitors learn something useful. This   
+96 arms race drives the continued emergence of ever new innovative and sophisticated capabilities   
+97 necessary to out-compete adversaries. Evolutionary Algorithms (EA) have been successfully used   
+98 to co-evolve multiple competing entities [32, 29]. However, in sequential decision problems EA   
+99 algorithms discard most of the information by not looking at the whole state-action trajectories   
+100 the agents encounter throughout their lifetime. This theoretical disadvantage limits their potential   
+101 efficiency to tackle sequential problems when compared with RL. Empirically, EA algorithms   
+102 usually have a higher variance when compared with gradient methods [30, 23, 24]. With regards   
+103 to gradient methods (deep learning methods in particular), impressive results have been recently   
+104 achieved by training NN, through back-propagation, to compete against each other in simulated games   
+105 (OpenFive [4], AlphaZero [31], GAN [11]). More closely aligned with our proposed methodology,   
+106 OpenAI has recently developed Neural MMO [37], a simulated environment that captures some   
+107 important properties of life on Earth. In Neural MMO artificial agents, represented by NN, need to   
+108 forage for food and water to survive in a never-ending simulation. Currently, Neural MMO agents   
+109 can not reproduce and their goal is to maximise their own survival, instead of maximising the survival   
+110 and reproduction success of their genes as it happens in nature. We extend this work by introducing   
+111 genes, the ability for agents to reproduce and we align the agents’ reward with evolution. These   
+112 are key properties of life on Earth that we must have in simulation environments if we hope to have   
+113 them evolve similar solutions to the ones evolved by nature (in other words, these are key properties   
+114 to achieve convergent evolution - see Appendix ?? for more details on why this important for AI   
+115 research).   
+116 Cooperative MARL Cooperative MARL is an active research area within RL that has been   
+117 experiencing fast progress [26, 3, 9]. The setting is usually approached in a binary way [4, 41, 20].   
+118 Agents are grouped into teams and agents within the same team fully cooperate amongst each other   
+119 whilst agents from different teams don’t cooperate at all (cooperation is either one or zero); we define   
+120 this scenario as the binary cooperative setting. The teams may have a fixed number of members or   
+121 change dynamically [19, 27, 40, 5]. The most straightforward solution for this setting would be to   
+122 train independent learners to maximise their team’s reward. However, independent learners would   
+123 face a non-stationary learning problem. The MADDPG [22] algorithm tackles this problem by using   
+124 a multi-agent policy gradient method with a centralised critic and decentralised actors so that training   
+125 takes into account all the states and actions of the entire team but during execution each agent can   
+126 act independently. More relevant to our work, factored value functions[12, 27] such as Transfer   
+127 Planning [40] Value Decomposition Networks (VDN) [38] and Q-Mix [28] use different methods to   
+128 decompose the team’s central action-value function into the decentralised action-value functions. We   
+129 build on top of VDN (which is further explained in the Appendix D) to extend the concept of team to   
+130 the concept of family and introduce continuous degrees of cooperation.
+
+# 131 3 Background
+
+132 Reinforcement Learning We recall the single agent fully-observable RL setting [39], where the   
+133 environment is typically formulated as a Markov decision process (MDP). At every time step,   
+134 $t = 1 , 2 , \dots$ , the agent observes the environment’s state $s _ { t } \in S$ , and uses it to select an action $a _ { t } \in { \mathcal { A } }$   
+135 As a consequence, the agent receives a reward $r _ { t } \in \mathcal { R } \subset \mathbb { R }$ and the environment transitions to the state   
+136 $s _ { t + 1 }$ . The tuple $\left( { { s _ { t + 1 } } , { r _ { t } } } \right)$ is sampled from the static probability distribution $p : { \mathcal { S } } \times { \mathcal { A } }  { \mathcal { P } } ( S \times { \mathcal { R } } )$   
+137 whilst the actions $a _ { t }$ are sampled from the parametric policy function $\pi _ { \theta } : { \mathcal { S } }  { \mathcal { P } } ( { \mathcal { A } } )$ :
+
+$$
+s _ { t + 1 } , r _ { t } \sim p ( s _ { t + 1 } , r _ { t } | s _ { t } , a _ { t } ) , \quad a _ { t } \sim \pi _ { \theta } ( a _ { t } | s _ { t } )
+$$
+
+138 The goal of the agent is to find the optimal policy parameters $\theta ^ { * }$ that maximise the expected return   
+139 $\bar { R } = \mathbb { E } [ \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } r _ { t } ]$ , where $\gamma$ is the discount factor. In the more general framework, the state is   
+140 only partially observable, meaning that the agent can not directly observe the state but instead it   
+141 observes $o _ { t } \in \mathcal { O }$ which is typically given by a function of the state. In this situation, the environment   
+142 is modelled by a partial observable Markov decision process (POMDP) and the policy usually   
+143 incorporates past history $h _ { t } = a _ { 0 } o _ { 0 } r _ { 0 } , \ldots , a _ { t - 1 } o _ { t - 1 } r _ { t - 1 }$ .   
+144 Q-Learning and Deep Q-Networks The action-value function $Q ^ { \pi }$ gives the estimated return when   
+145 the agent has the state history $h _ { t }$ , executes action $a _ { t }$ and follows the policy $\pi$ on the future time   
+146 steps. It can be recursively defined by $Q ^ { \pi } ( h _ { t } , a _ { t } ) = \mathbb { E } _ { s _ { t + 1 } , r _ { t } \sim p } \big [ r _ { t } + \gamma \mathbb { E } _ { a _ { t + 1 } \sim \pi } \big [ Q ^ { \pi } ( h _ { t + 1 } , a _ { t + 1 } ) \big ] \big ]$ . Q  
+147 learning and Deep Q-Networks (DQN) [25] are popular methods for obtaining the optimal action value   
+148 function $Q ^ { * }$ . Once we have $Q ^ { * }$ , the optimal policy is also available as $\pi ^ { * } = \arg \operatorname* { m a x } _ { a _ { t } } Q ^ { * } ( h _ { t } , a _ { t } )$ .   
+149 In DQN, the action-value function is approximated by a deep NN with parameters $\theta$ . $Q _ { \theta } ^ { * }$ is found by   
+150 minimising the loss function:
+
+$$
+\mathcal { L } _ { t } ( \theta ) = \mathbb { E } _ { h _ { t } , a _ { t } , r _ { t } , h _ { t + 1 } } [ ( y _ { t } - Q _ { \theta } ^ { \pi } ( h _ { t } , a _ { t } ) ) ^ { 2 } ] , \quad \mathrm { w h e r e ~ } y _ { t } = r _ { t } + \gamma \operatorname* { m a x } _ { a ^ { \prime } } Q _ { \theta ^ { \prime } } ^ { \pi } ( a _ { t + 1 } , h _ { t + 1 } ) ,
+$$
+
+where 151 $\pi$ is the $\epsilon$ -greedy policy which takes action arg $\operatorname* { m a x } _ { a _ { t } } Q ^ { \pi } ( a _ { t } , h _ { t } )$ with probability $1 - \epsilon$ , and 152 takes a random action with probability $\epsilon$ . $\theta ^ { \prime }$ are the parameters of a target network that are periodically 153 copied from $\theta$ and kept constant for a number of iterations.
+
+154 Multi-Agent Reinforcement Learning In this work, we consider the MARL setting where the   
+155 underlying environment is modelled by a partially observable stochastic game [13]. In this setting,   
+156 the environment is populated by multiple agents which have individual observations and rewards and   
+157 act according to individual policies. Their goal is to maximise their own expected return.
+
+# 158 4 Evolution via Evolutionary Reward
+
+159 In this section, we propose a reward function that enables RL algorithms to search for policies with   
+160 increasingly evolutionary success. We call this reward the evolutionary reward because it is always   
+161 aligned with the fitness function. We also propose a specific RL algorithm that is particularly suited   
+162 to maximise the evolutionary reward in open-ended evolutionary environments however other RL   
+163 algorithms could also be used.   
+164 Evolutionary reward The evolutionary reward of an agent is proportional to the number of copies   
+165 its genes have in the world’s population. Maximising this reward leads to the maximisation of the   
+166 survival and reproduction success of the genes an agent carries. We start by defining the kinship   
+167 function between a pair of agents $i$ and $j$ , who carry $N$ genes represented by the integer vectors $g ^ { i }$   
+168 and $g ^ { j }$ (we chose to use $\textbf {  { g } }$ for genome, which in biology is the set of genes an agent carries):
+
+$$
+k \colon \mathbb { Z } ^ { N } \times \mathbb { Z } ^ { N } \to [ 0 , 1 ] , \qquad k ( g ^ { i } , g ^ { j } ) = \frac { 1 } { N } \sum _ { p = 1 } ^ { N } \delta _ { g _ { p } ^ { i } , g _ { p } ^ { j } } \quad ,
+$$
+
+169 where $\delta _ { g _ { p } ^ { i } , g _ { p } ^ { j } }$ is the Kronecker delta which is one if $g _ { p } ^ { i } = g _ { p } ^ { j }$ and zero otherwise. When agent $i$ is alive   
+170 at time $t + 1$ , it receives the reward:
+
+$$
+r _ { t } ^ { i } = \sum _ { j \in \mathcal { A } _ { t + 1 } } k ( \pmb { g } ^ { i } , \pmb { g } ^ { j } ) ,
+$$
+
+171 where $\boldsymbol { \mathcal { A } } _ { t + 1 }$ is the set of agents alive at the instant $t + 1$ . Note that since agent $i$ is alive at $t + 1$ ,   
+172 $\boldsymbol { \mathcal { A } } _ { t + 1 }$ includes agent $i$ . $T ^ { i } - 1$ is the last time step that agent $i$ is alive and so, at this instant, the agent   
+173 receives its final reward which is proportional to the discounted sum of the number of times its genes   
+174 will be present on other agents after its death:
+
+$$
+r _ { T ^ { i } - 1 } ^ { i } = \sum _ { t = T ^ { i } } ^ { \infty } \gamma ^ { t - T ^ { i } } \sum _ { j \in { \mathcal A } _ { t } } k ( { \boldsymbol g } ^ { i } , { \boldsymbol g } ^ { j } ) ,
+$$
+
+175 with this reward function, the agents are incentivised to maximise the survival and replication success   
+176 of the genes they carry. In the agent-centered view, the agents are incentivised to survive and replicate,   
+177 but also to help their family (kin) survive and replicate; and to make sure that when they die their   
+178 family is in a good position to carry on surviving and replicating. The degree of collaboration with   
+179 other family members depends on the overlap between their genotype as it happens in nature.   
+180 The discount factor, $\gamma$ , needs to be in the interval $[ 0 , 1 [$ to ensure the final reward remains bounded.   
+181 Due to the exponential discounting we can compute the final reward up to an error of $\epsilon$ by summing   
+182 over a finite period of time denoted by the effective horizon $( h _ { e } )$ . To see how to compute the $h _ { e }$ for   
+183 a given environment and $\epsilon$ see the Appendix G.1. By computing the final reward this way, we can   
+184 now use RL algorithms like Q-learning to train agents with this evolutionary reward. However, in the   
+185 next section we introduce a more practical algorithm that allows us to estimate the final reward more   
+186 efficiently.   
+187 Evolutionary Value-Decomposition Networks We propose Evolutionary Value-Decomposition   
+188 Networks (E-VDN) as an extension of VDN [38] (explained in the Appendix D) from the binary   
+189 cooperative setting with static teams to the continuous cooperative setting with dynamic families.   
+190 E-VDN helps us reduce the variance of the value estimation and allows us to estimate the final   
+191 evolutionary reward without having to simulate the environment forward for $h _ { e }$ iterations.   
+192 Within a team, each agent fully cooperates with all the other members of the team, and it does not   
+193 cooperate at all with any agent outside of the team. Moreover, if $a$ and $b$ are members of the same   
+194 team and $c$ is a member of $a$ ’s team then $c$ and $b$ are also in the same team. Within a family, the   
+195 degrees of cooperation amongst its members depends on their kinship degree (which can be any real   
+196 number from 0 to 1). Also, if $a$ and $b$ are members of the same family and $c$ is part of $a$ ’s family, $c$ is   
+197 not necessarily part of $b$ ’s family.   
+198 Each agent $i$ sees the members of its family from an unique perspective, based on the kinship degree it   
+199 shares with them. In E-VDN, each agent $i$ has a joint action-value function, $Q ^ { i }$ . E-VDN assumes $Q ^ { i }$   
+200 can be composed by averaging the action-value functions across the members of $i$ ’s family weighted   
+201 by their kinship with agent $i$ (this is similar to the VDN’s assumption):
+
+$$
+Q ^ { i } ( ( h _ { t } ^ { 1 } , h _ { t } ^ { 2 } , \dots , h _ { t } ^ { | { \cal A } _ { t } | } ) , ( a _ { t } ^ { 1 } , a _ { t } ^ { 2 } , \dots , a _ { t } ^ { | { \cal A } _ { t } | } ) ) \approx \frac { 1 } { n _ { t } ^ { i } } \sum _ { j \in { \cal A } _ { t } } k ( g ^ { i } , g ^ { j } ) \tilde { Q } ^ { j } ( h _ { t } ^ { j } , a _ { t } ^ { j } | \tilde { \theta } _ { j } ) ,
+$$
+
+202 where $n _ { t } ^ { i }$ is a normalisation coefficient defined as $\begin{array} { r } { n _ { t } ^ { i } = \sum _ { j \in \mathcal { A } _ { t } } k ( \pmb { g } ^ { i } , \pmb { g } ^ { j } ) , \tilde { Q } _ { t } ^ { j } } \end{array}$ is the output of a NN   
+203 with parameters $\widetilde { \theta } _ { j }$ and with the input $( h _ { t } ^ { j } , a _ { t } ^ { j } )$ . Composing $Q ^ { i }$ with an average, instead of a sum   
+204 as it happens in VDN, is necessary as E-VDN allows the number of value functions contributing to   
+205 the composition to vary as the family gets bigger or smaller (agents born and die). This averaging   
+206 allows us to incorporate the local observations of each family member and reduce variance in the   
+207 value estimation.   
+208 More importantly, E-VDN allows us to deal with the difficulty of estimating the final reward (5) in a   
+209 particularly convenient way. As is clear from its definition (5), the final reward is the expected sum   
+210 (over time) of kinship that agent $i$ has with other agents $j$ after its death. The key idea is to note that   
+211 this value $( r _ { T ^ { i } - 1 } ^ { i } )$ can be approximated by the Q-value of other agents $j$ that are close to (have high   
+212 kinship with) agent $i$ :
+
+$$
+\hat { r } _ { T ^ { i } - 1 } ^ { i } = \left\{ \begin{array} { l l } { \frac { 1 } { n _ { T ^ { i } } ^ { i } } \sum _ { j \in \mathcal { A } _ { T ^ { i } } } k ( g ^ { i } , g ^ { j } ) \tilde { Q } _ { T ^ { i } } ^ { j } ( \dots ) \approx Q _ { T ^ { i } } ^ { i } ( \dots ) } & { \mathrm { i f ~ } n _ { T ^ { i } } ^ { i } > 0 } \\ { 0 } & { \mathrm { i f ~ } n _ { T ^ { i } } ^ { i } = 0 } \end{array} \right.
+$$
+
+213 The final reward is zero if, and only if, at the time of its death the agent has no surviving family.
+
+Each 214 $\tilde { Q } _ { t } ^ { i }$ is trained by back-propagating gradients, $g _ { t } ^ { i }$ , from the Q-learning rule:
+
+$$
+g _ { t } ^ { i } = \nabla \pmb { \theta } _ { i } ( y _ { t } ^ { i } - \frac { 1 } { n _ { t } ^ { i } } \sum _ { j \in \cal A _ { t } } k ( \pmb { g } ^ { i } , \pmb { g } ^ { j } ) \tilde { Q } ^ { j } ( h _ { t } ^ { j } , a _ { t } ^ { j } | \tilde { \pmb { \theta } } _ { j } ) ) ^ { 2 } \approx \nabla \pmb { \theta } _ { i } ( y _ { t } ^ { i } - Q _ { t } ^ { i } ( \dots | \pmb { \theta } _ { i } ) ) ^ { 2 } ,
+$$
+
+where 215 $\theta _ { i }$ is the concatenation of all the parameters $\widetilde { \theta } _ { j }$ , used in each $\tilde { Q } ^ { j }$ , contributing to the estimation 216 of $Q ^ { i }$ ; i.e. $\pmb { \theta } _ { i } : = \{ \widetilde { \theta } _ { j } \} _ { j }$ s.t. $k ( { \pmb g } ^ { i } , { \pmb g } ^ { j } ) > 0$ . Note that $\tilde { Q } ^ { i }$ are neural networks with parameters $\widetilde { \theta } _ { i }$ and $Q ^ { i }$ is 217 simply the average stated in (6).
+
+The learning targets 218 $y _ { t } ^ { i }$ are given by:
+
+$$
+\begin{array} { r } { y _ { t } ^ { i } = \left\{ \begin{array} { l l } { r _ { t } ^ { i } + \gamma \operatorname* { m a x } _ { { \pmb a } _ { t + 1 } } Q _ { t + 1 } ^ { i } ( . . . ) | \pmb \theta _ { i } ^ { \prime } ) } & { \mathrm { i f ~ } t < T ^ { i } - 1 } \\ { \hat { r } _ { T ^ { i } - 1 } ^ { i } } & { \mathrm { i f ~ } t = T ^ { i } - 1 } \end{array} \right. , } \end{array}
+$$
+
+219 $r _ { t } ^ { i }$ is the evolutionary reward (4), $\hat { r } _ { T ^ { i } - 1 } ^ { i }$ is the estimate of the final evolutionary reward (7) and $\theta _ { i } ^ { \prime }$   
+220 are the parameters of the target network that get periodically copied from $\theta _ { i }$ . We don’t use a replay   
+221 buffer in our training (which is commonly used in DQN) due to the non-stationary of multi-agent   
+222 environments (more about this in the Appendix G.2).
+
+![](images/aee2170b9b17f34f89c3137d615986a64df5b506af473a58a2040f54f5ee1896.jpg)  
+Figure 1: The binary environment.
+
+Since the joint action-value $Q ^ { i }$ increases monotonically with increasing $\tilde { Q } ^ { i }$ , an agent acting greedily with respect to its action-value function will also act greedily in respect to its family action-value function: arg m $\begin{array} { r } { \operatorname { 1 a x } _ { a _ { t } ^ { i } } Q _ { t } ^ { i } ( . . . ) \approx \arg \operatorname* { m a x } _ { a _ { t } ^ { i } } \tilde { Q } ^ { i } ( h _ { t } ^ { i } , a _ { t } ^ { i } ) . } \end{array}$ .
+
+# 5 Experimental Setup
+
+We want to test two hypotheses: 1) E-VDN is particularly well suited to make agents climb the fitness landscape in open-ended evolutionary environments; 2) E-VDN is able to increase the evolutionary fitness of agents in non-binary cooperative environments. To test the first hypothesis we need to compare E-VDN with another popular evolutionary algorithm. To make it easier to implement the competing algorithm we are going to use a binary cooperative environment to test the first hypothesis. To test the second hypothesis we will use a non-binary cooperative environment. Note, if an agent carries more than one gene (like it happens in nature) we have a non-binary environment.
+
+234 In this section, we give a quick overview of these two multi-agent environments, as well as details   
+235 of the network architectures and the training regime. For a more complete description of the   
+236 environments, you can refer to the Appendix E. In the binary environment, we compared our   
+237 algorithm with a popular Evolution Strategies algorithm (CMA-ES [14]), and describe the training   
+238 regime used for CMA-ES in the Appendix F.
+
+The Binary Environment The binary environment is a 2-dimensional grid world, which is initialised with five agents carrying five unique genomes (Figure 1). At each time step, each agent may move one step and produce an attack to another agent in an adjacent tile. When an agent moves to a tile with food it collects all the food available in it. If an agent chooses to produce an attack, it decreases its victim’s health by one point, if the victim’s health reaches zero it dies and $50 \%$ of its collected food is captured by the attacker. The food is used to survive (one unit of food must be consumed every time step to remain alive), and to reproduce. When agents are within their fertile age and they have stored enough food, they reproduce themselves asexually and give birth to an agent carrying an exact copy of their genome. Each genome has only a single gene and there are no mutations. These rules make the cooperation between agents binary, agents either fully-cooperate (they have the exact same genome) or they don’t cooperate at all (their genome has no overlap).
+
+The Non-binary Environment The non-binary environment has the same rules as the binary environment with the difference that the agents now have 32 genes in their genome and they reproduce sexually instead of asexually. When two fertile agents are adjacent, they give birth to an agent who’s genome is composed by two halves of the genes of each parent, selected randomly. There are no genders, any agent can reproduce with any other agent. These rules give rise to different levels of collaboration: from 0 to 1 in steps of $\frac { 1 } { 3 2 }$ .
+
+256 Policy Each agent observes a 5x5 square crop of the surrounding state (Figure 1). The agent   
+257 sees six features for every visible tile; i.e. the input is a 5x5x6 tensor. This includes two features   
+258 corresponding to tile properties (food available and whether it is occupied or not) and four features   
+259 corresponding to the occupying agents’ properties (age, food stored, kinship and health). Besides   
+260 these local inputs, each agent also observes its absolute position, family size and the total number   
+261 of agents in the world. We intend to remove these extra inputs in future work as we provide agents   
+262 with memory (we’re currently providing our policy with $\hat { o _ { t } ^ { i } }$ instead of $h _ { t } ^ { i \cdot }$ ). The NN has ten outputs   
+263 (five movement actions with no attack and five movement actions with an attack). In this work, we   
+264 used two different feed forward architectures: one is simply a fully connected NN with three hidden   
+265 layers and 244, 288 parameters in total, the other architecture is composed by convolutional and   
+266 dense layers and it is much smaller containing only 23, 616 parameters. The smaller NN was used to   
+267 compare our algorithm with an evolutionary algorithm which doesn’t scale well to larger networks.
+
+Training details In this work, the genome does not directly encode the policy, however, we think it would be interesting to do that in future work. In the binary environment, we train five different policies (with the same architecture but different weights) simultaneously. At each training episode, we sample five policies with replacement and assign each one to one of the five unique genomes. We do this, to force each policy to interact with all other policies (including itself), increasing their robustness in survival and reproduction. During the test episodes, no sampling occurs, each policy is simply assigned to each unique genome. The training episodes had a length between 450 and 550 (note that the reward is computed as if there was no episode end), and the test episodes had a length of 500 steps.
+
+277 In the non-binary environment, due to the large number of unique genomes, it is unfeasible to assign   
+278 a unique policy to each unique genome. To keep things simple, we chose to use only one policy in   
+279 this environment. This was not possible to do with CMA-ES, so we did not implement it in this   
+280 environment (more about CMA-ES on Appendix F).
+
+Traits encoded by the genes In the non-binary environment, we can think of each of the 32 genes to change some visual feature (e.g. facial feature) of their agent so that it can be better recognised by its family. In the binary environment, besides the gene encoding this visual feature it also encodes which policy, chosen from a set of 5 policies, the agent is going to have. Note that the genes encode fixed traits (they don’t change during an agent’s lifetime) and their frequency in the population evolve through normal evolution (death and birth). With EvER we don’t need evolution to create the reward function and continuously align it with the fitness function. The agent’s brain is always trying to learn the right things for the survival of its genes, however, the actual genes are evolving at the normal pace of evolution.
+
+290 To analyse the impact of our reward function, we deliberately chose to minimise entanglement   
+291 between genes and other aspects of the agents. However, EvER can be easily used in environments   
+292 where genes encode more traits like the agent’s abilities, visual features, initial weights and the   
+293 topology of its policy.
+
+Evaluation Metrics In our simple environments, fitter policies can use the environment resources more efficiently and increase their population size to larger numbers. Therefore, to evaluate the performance of the algorithms in generating increasingly fitter species we track the average population size along training time.
+
+# 6 Results
+
+Training agents with E-VDN generates quite an interesting evolutionary history. Throughout the binary environment history, we found four distinct eras where agents engage in significantly distinct behaviour patterns $1 ^ { \mathrm { s t } }$ row of fig. 2). In the first era (the blue line - which lasts only a few hundred iterations), the agents learned how to survive, and through their encounters with the other founding agents, they have learnt that it was always (evolutionary) advantageous to attack other agents. In the second era (orange line), the agents’ food-gathering skills increased to a point where they started to reproduce. In this era, the birth-rate and population numbers increased fast. However, with the extra births, intra-family encounters became more frequent, and intra-family violence rose to its all-time maximum driving the average life span down. This intra-family violence quickly decreased in the third era (green line), as agents started to recognize their kin. Kin detection allowed for selective kindness and selective violence, which took the average life span to its all-time maximum. Finally,
+
+![](images/dad021ed60b9287668f6b891462ea1be5b4857570da1ab99901c11e6391b439b.jpg)  
+Figure 2: ( $1 ^ { \mathrm { s t } }$ row) Results obtained using E-VDN with the larger NN, each point was obtained by averaging 20 test episodes. The different colours correspond to different eras. This plot was generated with a denser version of the evolutionary reward (more details on the Appendix G.3). $2 ^ { \mathrm { n d } }$ row) Results obtained using CMA-ES and E-VDN algorithms with the smaller NN and the standard evolutionary reward (4). Both algorithms were trained with 20 CPUs each.
+
+310 in the fourth era (red line), agents learned how to sacrifice their lives for the future of their family.   
+311 Old infertile agents started allowing the younger generation to eat them without retaliation. Through   
+312 this cannibalism, the families had found a system for wealth inheritance. A smart allocation of the   
+313 family’s food resources in the fitter generation led to an increase in the population size with the cost   
+314 of a shorter life span. This behaviour emerges because the final reward (5) incentivises agents to   
+315 plan for the success of their genes even after their death. This behaviour is further investigated in   
+316 the Appendix H.1. These results show that optimising open-ended evolutionary environments with   
+317 E-VDN does indeed generate increasingly complex behaviours.   
+318 The $2 ^ { \mathrm { n d } }$ row of Figure 2, shows the macro-statistics obtained by training the smaller NN with CMA  
+319 ES and E-VDN. From the figure, we observe that E-VDN is able to produce a larger population of   
+320 agents with a longer life-span and a higher birth rate. A small population means that many resources   
+321 are left unused by the current population, this creates an opportunity for a new and more efficient   
+322 species to collect the unused resources and multiply its numbers. These opportunities are present in   
+323 the CMA-ES environment, however the algorithm could not find them, which suggests that E-VDN   
+324 is better at finding the way up the fitness landscape than CMA-ES. Video 1, shows that each family   
+325 trained with CMA-ES creates a swarm formation in a line that moves around the world diagonally.   
+326 When there is only one surviving family, this simple strategy allows agents to only step into tiles   
+327 that have reached their maximum food capacity. However, this is far from an evolutionarily stable   
+328 strategy [35] (ESS; i.e. a strategy that is not easily driven to extinction by a competing strategy), as   
+329 we verify when we place the best two families trained with CMA-ES on the same environment as the   
+330 best two E-VDN families and observe the CMA-ES families being consistently driven quickly to   
+331 extinction by their competition (fig. 4.a of Appendix B).   
+332 Our results, in the non-binary environment, show that in a non-binary cooperative setting E-VDN   
+333 also improves the ability of the trained policy to survive and replicate its genes (Figure 4.b,c and d   
+334 of Appendix B). This is a key feature that evolutionary algorithms should have in order to take the   
+335 research in open-ended evolutionary environments further. Note, that the non-binary environment   
+336 is much harder than the binary one. To replicate, agents need to be adjacent to other agents. In the   
+337 beginning, all agents are unrelated making it dangerous to get adjacent to another agent as it often   
+338 leads into attacks, but it is also dangerous to get too far away from them since with a limited vision it   
+339 is hard to find a fertile mate once they lose sight of each other. Video 2 shows a simulation of the   
+340 evolved policy being run on the non-binary environment, it seems that agents found a way to find   
+341 mates by moving to a certain region of the map (the breeding ground) once they are fertile.
+
+# 42 7 Conclusion & Future Work
+
+43 This paper has introduced an evolutionary reward function that when maximised also maximises the   
+44 evolutionary fitness of the agent. This allows RL to be used as a tool for research of open-ended   
+345 evolutionary systems. To implement this reward function, we extended the concept of team to the   
+346 concept of family and introduce continuous degrees of cooperation. Future work could explore three   
+347 directions: 1) Explore a different reward function that makes agents maximise the expected geometric   
+348 growth rate of their genes; 2) Research the minimum set of requirements to emerge natural cognitive   
+349 abilities in artificial agents such as identity awareness and recognition, friendship and hierarchical   
+350 status (by following our proposed methodology for progress in AI (Appendix ??)) 3) Extend the use   
+351 of genes to encode more fixed traits in the agent like its initial weights and the topology of its policy.
+
+# 352 Broader Impact
+
+Simulating the key processes that generated life and intelligence in nature is a promising path to further our understanding in this field and unlock ever more intelligent algorithms able to solve useful problems for the world. However, embodying AI with the goal to survive and self-reproduce can be dangerous, and should never be done outside of a sand-boxed environment.
+
+# References
+
+[1] David Ackley and Michael Littman. Interactions between learning and evolution. Artificial life II, 10:487–509, 1991.   
+[2] BURT Austin, Robert Trivers, and Austin Burt. Genes in conflict: the biology of selfish genetic elements. Harvard University Press, 2009.   
+[3] Trapit Bansal, Jakub Pachocki, Szymon Sidor, Ilya Sutskever, and Igor Mordatch. Emergent complexity via multi-agent competition. arXiv preprint arXiv:1710.03748, 2017.   
+[4] Christopher Berner, Greg Brockman, Brooke Chan, Vicki Cheung, Przemysław D˛ebiak, Christy Dennison, David Farhi, Quirin Fischer, Shariq Hashme, Chris Hesse, et al. Dota 2 with large scale deep reinforcement learning. arXiv preprint arXiv:1912.06680, 2019.   
+[5] Wendelin Böhmer, Vitaly Kurin, and Shimon Whiteson. Deep coordination graphs. arXiv preprint arXiv:1910.00091, 2019. [6] Richard Dawkins. The selfish gene. 1976.   
+[7] Richard Dawkins. Twelve misunderstandings of kin selection. Zeitschrift für Tierpsychologie, 51(2):184–200, 1979.   
+[8] Stefan Elfwing, Eiji Uchibe, Kenji Doya, and Henrik I Christensen. Co-evolution of shaping rewards and meta-parameters in reinforcement learning. Adaptive Behavior, 16(6):400–412, 2008.   
+[9] Jakob N Foerster, Gregory Farquhar, Triantafyllos Afouras, Nantas Nardelli, and Shimon Whiteson. Counterfactual multi-agent policy gradients. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018.   
+[10] Andy Gardner and Francisco Úbeda. The meaning of intragenomic conflict. Nature ecology & evolution, 1(12):1807–1815, 2017.   
+[11] Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pages 2672–2680, 2014.   
+[12] Carlos Guestrin, Daphne Koller, and Ronald Parr. Multiagent planning with factored mdps. In Advances in neural information processing systems, pages 1523–1530, 2002.   
+[13] Eric A Hansen, Daniel S Bernstein, and Shlomo Zilberstein. Dynamic programming for partially observable stochastic games. In AAAI, volume 4, pages 709–715, 2004.   
+[14] Nikolaus Hansen, Sibylle D Müller, and Petros Koumoutsakos. Reducing the time complexity of the derandomized evolution strategy with covariance matrix adaptation (cma-es). Evolutionary computation, 11(1):1–18, 2003.   
+[15] Nikolaus Hansen, Youhei Akimoto, and Petr Baudis. CMA-ES/pycma on Github. Zenodo, DOI:10.5281/zenodo.2559634, February 2019. URL https://doi.org/10.5281/zenodo. 2559634.   
+[16] Verena Heidrich-Meisner and Christian Igel. Evolution strategies for direct policy search. In International Conference on Parallel Problem Solving from Nature, pages 428–437. Springer, 2008.
+
+96 [17] Verena Heidrich-Meisner and Christian Igel. Variable metric reinforcement learning methods applied to the noisy mountain car problem. In European Workshop on Reinforcement Learning, pages 136–150. Springer, 2008. [18] Verena Heidrich-Meisner and Christian Igel. Hoeffding and bernstein races for selecting policies in evolutionary direct policy search. In Proceedings of the 26th Annual International Conference on Machine Learning, pages 401–408. ACM, 2009. [19] Jelle R Kok, Eter Jan Hoen, Bram Bakker, and Nikos Vlassis. Utile coordination: Learning interdependencies among cooperative agents. In EEE Symp. on Computational Intelligence and Games, Colchester, Essex, pages 29–36, 2005. [20] Karol Kurach, Anton Raichuk, Piotr Stanczyk, Michał Zaj ˛ac, Olivier Bachem, Lasse Espeholt, ´ Carlos Riquelme, Damien Vincent, Marcin Michalski, Olivier Bousquet, et al. Google research football: A novel reinforcement learning environment. arXiv preprint arXiv:1907.11180, 2019. [21] Richard L Lewis, Satinder Singh, and Andrew G Barto. Where do rewards come from? In Proceedings of the International Symposium on AI-Inspired Biology, pages 2601–2606, 2010. [22] Ryan Lowe, Yi Wu, Aviv Tamar, Jean Harb, OpenAI Pieter Abbeel, and Igor Mordatch. Multiagent actor-critic for mixed cooperative-competitive environments. In Advances in Neural Information Processing Systems, pages 6379–6390, 2017. [23] Simon M Lucas and Thomas P Runarsson. Temporal difference learning versus co-evolution for acquiring othello position evaluation. In 2006 IEEE Symposium on Computational Intelligence and Games, pages 52–59. IEEE, 2006. [24] Simon M Lucas and Julian Togelius. Point-to-point car racing: an initial study of evolution versus temporal difference learning. In 2007 iEEE symposium on computational intelligence and games, pages 260–267. IEEE, 2007. [25] Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529, 2015. [26] Frans A. Oliehoek and Christopher Amato. A Concise Introduction to Decentralized POMDPs. SpringerBriefs in Intelligent Systems. Springer, May 2016. doi: 10.1007/978-3-319-28929-8. URL http://www.fransoliehoek.net/docs/OliehoekAmato16book.pdf. [27] Frans A Oliehoek, Shimon Whiteson, Matthijs TJ Spaan, et al. Approximate solutions for factored dec-pomdps with many agents. In AAMAS, pages 563–570, 2013. [28] Tabish Rashid, Mikayel Samvelyan, Christian Schroeder De Witt, Gregory Farquhar, Jakob Foerster, and Shimon Whiteson. Qmix: monotonic value function factorisation for deep multi-agent reinforcement learning. arXiv preprint arXiv:1803.11485, 2018. [29] Craig W Reynolds. Competition, coevolution and the game of tag. In Proceedings of the Fourth International Workshop on the Synthesis and Simulation of Living Systems, pages 59–69, 1994. [30] Thomas Philip Runarsson and Simon M Lucas. Coevolution versus self-play temporal difference learning for acquiring position evaluation in small-board go. IEEE Transactions on Evolutionary Computation, 9(6):628–640, 2005. [31] David Silver, Thomas Hubert, Julian Schrittwieser, Ioannis Antonoglou, Matthew Lai, Arthur Guez, Marc Lanctot, Laurent Sifre, Dharshan Kumaran, Thore Graepel, et al. A general reinforcement learning algorithm that masters chess, shogi, and go through self-play. Science, 362(6419):1140–1144, 2018. [32] Karl Sims. Evolving 3d morphology and behavior by competition. Artificial life, 1(4):353–372, 1994. [33] Satinder Singh, Richard L Lewis, Andrew G Barto, and Jonathan Sorg. Intrinsically motivated reinforcement learning: An evolutionary perspective. IEEE Transactions on Autonomous Mental Development, 2(2):70–82, 2010.
+
+[34] J Maynard Smith. Group selection and kin selection. Nature, 201(4924):1145, 1964.
+
+[35] J Maynard Smith and George R Price. The logic of animal conflict. Nature, 246(5427):15, 1973.
+
+[36] Kenneth O Stanley and Risto Miikkulainen. Evolving neural networks through augmenting topologies. Evolutionary computation, 10(2):99–127, 2002.
+
+[37] Joseph Suarez, Yilun Du, Phillip Isola, and Igor Mordatch. Neural mmo: A massively multiagent game environment for training and evaluating intelligent agents. arXiv preprint arXiv:1903.00784, 2019.
+
+[38] Peter Sunehag, Guy Lever, Audrunas Gruslys, Wojciech Marian Czarnecki, Vinicius Zambaldi, Max Jaderberg, Marc Lanctot, Nicolas Sonnerat, Joel Z Leibo, Karl Tuyls, et al. Valuedecomposition networks for cooperative multi-agent learning. arXiv preprint arXiv:1706.05296, 2017.
+
+[39] Richard S Sutton, Andrew G Barto, et al. Introduction to reinforcement learning, volume 2. MIT press Cambridge, 1998.
+
+[40] Elise Van der Pol and Frans A Oliehoek. Coordinated deep reinforcement learners for traffic light control. Proceedings of Learning, Inference and Control of Multi-Agent Systems (at NIPS 2016), 2016.
+
+[41] Oriol Vinyals, Igor Babuschkin, Wojciech M Czarnecki, Michaël Mathieu, Andrew Dudzik, Junyoung Chung, David H Choi, Richard Powell, Timo Ewalds, Petko Georgiev, et al. Grandmaster level in starcraft ii using multi-agent reinforcement learning. Nature, 575(7782):350–354, 2019.
+
+[42] Shimon Whiteson and Peter Stone. Evolutionary function approximation for reinforcement learning. Journal of Machine Learning Research, 7(May):877–917, 2006.
+
+[43] George C Williams. Adaptation and natural selection: a critique of some current evolutionary thought, volume 833082108. Princeton science library OCLC, 1966.
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes]   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes]   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [Yes] (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)? [No]   
+(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)? [No]   
+(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? [N/A] (b) Did you mention the license of the assets? [N/A] (c) Did you include any new assets either in the supplemental material or as a URL? [N/A]
+
+492 (d) Did you discuss whether and how consent was obtained from people whose data you’re   
+493 using/curating? [N/A]   
+494 (e) Did you discuss whether the data you are using/curating contains personally identifiable   
+495 information or offensive content? [N/A]   
+497 (a) Did you include the full text of instructions given to participants and screenshots, if   
+498 applicable? [N/A]   
+499 (b) Did you describe any potential participant risks, with links to Institutional Review   
+500 Board (IRB) approvals, if applicable? [N/A]   
+501 (c) Did you include the estimated hourly wage paid to participants and the total amount   
+502 spent on participant compensation? [N/A]

parse/train/3X8qZL4_WO/3X8qZL4_WO_content_list.json

@@ -0,0 +1,1163 @@
+[
+    {
+        "type": "text",
+        "text": "Mimicking Evolution with Reinforcement Learning ",
+        "text_level": 1,
+        "bbox": [
+            184,
+            122,
+            810,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            200,
+            580,
+            256
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            292,
+            535,
+            309
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 In nature, there are two processes driving the development of the brain: evolution   \n2 and learning. Evolution acts slowly, across generations, and amongst other things,   \n3 it defines what agents learn by changing their internal reward function. Learning   \n4 acts fast, within one’s lifetime, and it quickly updates agents’ policies to maximise   \n5 the evolved reward function. Although previous work has emulated both of these   \n6 processes working in tandem, the optimisation of the reward function in order to   \n7 serve the aims of the evolutionary process is very computationally expensive. This   \n8 work proposes a fixed reward function, the evolutionary reward, that aims to max  \n9 imise the number of current (and future) genetically similar agents. Furthermore,   \n10 we propose a way to approximate the joint action value by averaging the action   \n11 values of other agents weighted by their genetic similarity. In a finite environment   \n12 with limited resources this techniques drives improved survival mechanisms and   \n13 reproductive success. Given that this reward function is fixed, we avoid the com  \n14 putationally intense process of optimising it. We demonstrate the viability of our   \n15 evolutionary reward by testing it in two bio-inspired, open-ended environments and   \n16 monitoring a number of metrics such as population size and life expectancy. We   \n17 compare our technique with the state-of-the-art evolutionary algorithm: CMA-ES,   \n18 and show the superiority of work at producing agents that maximise the number of   \n19 its genes across time. ",
+        "bbox": [
+            148,
+            327,
+            766,
+            589
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "20 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            147,
+            621,
+            312,
+            638
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "21 Evolution is the only process we know of today that has given rise to general intelligence (as demon  \n22 strated in animals, and specifically in humans). This fact has been inspiring artificial intelligence (AI)   \n23 researchers to run evolution in artificial worlds that mimic key properties of life on Earth. One of   \n24 these key properties is open-endedness. This means that, as in nature, the fitness function (or any   \n25 goal function) of the environment is not defined anywhere but it simply emerges from the survival   \n26 and reproduction of genes. For this reason, we call these environments open-ended evolutionary   \n27 environments (OEEE). They are never-ending environments where adaptable agents are competing   \n28 for a common limited-resource to survive and replicate their genes. Using them for research is the   \n29 focus of the field of artificial life (ALife).   \n30 Our ability to run evolution efficiently in OEEE will dictate the success of ALife. In this work   \n31 we speed up the way evolution is ran in OEEE by introducing Evolution via Evolutionary Reward   \n32 (EvER). In EvER, each agent is born with an evolutionary reward that, when maximised by a learning,   \n33 it also maximises the survival and reproduction of the agent’s genes. Due to this property we say that   \n34 this reward is aligned with evolution. This allows learning to search for policies with increasingly   \n35 evolutionary fitness. Also, by guarantying this alignment we don’t need to go through the expensive   \n36 process of aligning the agents’ reward functions through evolution. This reward function was designed   \n37 to work on any OEEE.   \n38 In the remaining part of this introduction we 1) describe how evolution changes what we learn;   \n39 2) introduce our contribution and describe how maximising a reward function can lead to the   \n40 maximisation of evolutionary fitness. ",
+        "bbox": [
+            145,
+            655,
+            825,
+            780
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            786,
+            825,
+            897
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            92,
+            826,
+            133
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "41 1.1 Evolving what to learn ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            150,
+            370,
+            165
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "42 In nature, there are two different mechanisms driving the development of the brain. Evolution acts   \n43 slowly, across generations, and amongst other things, it defines what agents learn by changing their   \n44 internal reward function. Learning acts fast, within one’s lifetime, and it quickly updates agents’   \n45 policies to maximise pleasure and minimise pain. Combining these two methods has a long history   \n46 in AI research [1, 42, 8]. This combination (illustrated in Appendix B, Figure 3) results in a very   \n47 computationally expensive algorithm as it requires two loops 1) learning (the inner loop) where   \n48 agents maximise their innate reward functions across their lifetimes and 2) evolution (the outer loop)   \n49 where natural selection and mutation defines the reward functions for the next generation (amongst   \n50 other things, such as NN topologies and initial weights).   \n51 We say that a reward function is aligned with evolution when the maximisation of the reward leads   \n52 to the maximisation of the agent’s fitness. Through evolution the most aligned reward functions   \n53 get selected and increase their numbers. Intuitively, one can define the optimally aligned reward   \n54 function as the reward function that allows a learner to learn most quickly how to maximise its fitness,   \n55 assuming the conditions of the world (including other agents) remain the same. However, as agents   \n56 evolve and learn, they change their environment and its corresponding fitness function. This change,   \n57 increases the misalignment between the reward and fitness functions. Therefore, the optimally aligned   \n58 reward function is always chasing the ever changing fitness function (see Appendix C for a formal   \n59 description of this). However, in this paper, we show that in simulation it is possible to define a fixed   \n60 reward function which is always aligned, although not guaranteed to be optimally aligned, with the   \n61 essence of fitness: the ability of the individual to survive and reproduce its genes.   \n62 Our work allows learning to single-handedly drive the search for policies with increasingly evolution  \n63 ary fitness by ensuring the alignment of the reward function with the fitness function. This greatly   \n64 simplifies the two-loop algorithm used to combine evolution and learning that was described earlier in   \n65 this section. We can do this because our reward is extrinsic to the agent and therefore, only possible   \n66 within a simulation. ",
+        "bbox": [
+            147,
+            175,
+            825,
+            300
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            306,
+            825,
+            458
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            464,
+            825,
+            534
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "67 1.2 Learning to maximise evolutionary fitness ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            551,
+            503,
+            565
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "68 The distinction between an agent and a gene is key to understanding this paper. Formally, evolution is   \n69 a change in gene frequencies in a population (of agents) over time. The gene is the unit of evolution,   \n70 and an agent carries one or more genes. Richard Dawkins has famously described our bodies as   \n71 throwaway survival machines built for replicating immortal genes [6]. His line illustrates well the   \n72 gene-centered view of evolution [43, 6], a view that has been able to explain multiple phenomena   \n73 such as intragenomic conflict and altruism that are difficult to explain with organism-centered or   \n74 group-centered viewpoints [2, 10, 7]. From the gene’s perspective, the evolutionary process is a   \n75 constant competition for resources. However, from the agent’s perspective, the evolutionary process   \n76 is a mix between a cooperative exercise with agents that carry some of its genes (its family) and   \n77 a competition with unrelated agents. Evolution pressures agents to engage in various degrees of   \n78 collaboration depending on the degree of kinship between them and the agents they interact with (i.e.   \n79 depending on the amount of overlap between the genes they carry). This pressure for cooperation   \n80 amongst relatives was named kin selection [34].   \n81 Evolution acts on the gene level, but RL acts on the agent level. RL can be aligned with the   \n82 evolutionary process by noting what evolution does to the agents through its selection of genes:   \n83 evolution generates agents with increasing capabilities to maximise the survival and reproduction   \n84 success of the genes they carry. ",
+        "bbox": [
+            147,
+            577,
+            825,
+            756
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            148,
+            762,
+            825,
+            818
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related work ",
+        "text_level": 1,
+        "bbox": [
+            160,
+            838,
+            316,
+            854
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "86 Combining evolution and learning Combining evolution and learning has long history in AI   \n87 research. The evolutionary reinforcement learning algorithm, introduced in 1991 [1], makes the   \n88 evolutionary process determine the initial weights of two neural networks: an action and an evaluation   \n89 network. During an agent’s lifetime, learning adapts the action network guided by the output of   \n90 its innate and fixed (during its lifetime) evaluation network. $\\mathrm { N E A T + Q }$ [42] uses an evolutionary   \n91 algorithm, NEAT [36], to evolve topologies of NN and their initial weights so that they can better   \n92 learn using RL. In NEAT-Q the reward function remains fixed. However, evolutionary algorithms   \n93 have also been used to evolve potential-based shaping rewards and meta-parameters for RL [8].   \n94 Competing in Arms-race Every time adaptable entities compete against each other an arms-race   \n95 is created. Each entity’s task gets harder every time their competitors learn something useful. This   \n96 arms race drives the continued emergence of ever new innovative and sophisticated capabilities   \n97 necessary to out-compete adversaries. Evolutionary Algorithms (EA) have been successfully used   \n98 to co-evolve multiple competing entities [32, 29]. However, in sequential decision problems EA   \n99 algorithms discard most of the information by not looking at the whole state-action trajectories   \n100 the agents encounter throughout their lifetime. This theoretical disadvantage limits their potential   \n101 efficiency to tackle sequential problems when compared with RL. Empirically, EA algorithms   \n102 usually have a higher variance when compared with gradient methods [30, 23, 24]. With regards   \n103 to gradient methods (deep learning methods in particular), impressive results have been recently   \n104 achieved by training NN, through back-propagation, to compete against each other in simulated games   \n105 (OpenFive [4], AlphaZero [31], GAN [11]). More closely aligned with our proposed methodology,   \n106 OpenAI has recently developed Neural MMO [37], a simulated environment that captures some   \n107 important properties of life on Earth. In Neural MMO artificial agents, represented by NN, need to   \n108 forage for food and water to survive in a never-ending simulation. Currently, Neural MMO agents   \n109 can not reproduce and their goal is to maximise their own survival, instead of maximising the survival   \n110 and reproduction success of their genes as it happens in nature. We extend this work by introducing   \n111 genes, the ability for agents to reproduce and we align the agents’ reward with evolution. These   \n112 are key properties of life on Earth that we must have in simulation environments if we hope to have   \n113 them evolve similar solutions to the ones evolved by nature (in other words, these are key properties   \n114 to achieve convergent evolution - see Appendix ?? for more details on why this important for AI   \n115 research).   \n116 Cooperative MARL Cooperative MARL is an active research area within RL that has been   \n117 experiencing fast progress [26, 3, 9]. The setting is usually approached in a binary way [4, 41, 20].   \n118 Agents are grouped into teams and agents within the same team fully cooperate amongst each other   \n119 whilst agents from different teams don’t cooperate at all (cooperation is either one or zero); we define   \n120 this scenario as the binary cooperative setting. The teams may have a fixed number of members or   \n121 change dynamically [19, 27, 40, 5]. The most straightforward solution for this setting would be to   \n122 train independent learners to maximise their team’s reward. However, independent learners would   \n123 face a non-stationary learning problem. The MADDPG [22] algorithm tackles this problem by using   \n124 a multi-agent policy gradient method with a centralised critic and decentralised actors so that training   \n125 takes into account all the states and actions of the entire team but during execution each agent can   \n126 act independently. More relevant to our work, factored value functions[12, 27] such as Transfer   \n127 Planning [40] Value Decomposition Networks (VDN) [38] and Q-Mix [28] use different methods to   \n128 decompose the team’s central action-value function into the decentralised action-value functions. We   \n129 build on top of VDN (which is further explained in the Appendix D) to extend the concept of team to   \n130 the concept of family and introduce continuous degrees of cooperation. ",
+        "bbox": [
+            148,
+            869,
+            823,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            92,
+            825,
+            161
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            175,
+            825,
+            481
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            494,
+            825,
+            703
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "131 3 Background ",
+        "text_level": 1,
+        "bbox": [
+            145,
+            723,
+            308,
+            739
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "132 Reinforcement Learning We recall the single agent fully-observable RL setting [39], where the   \n133 environment is typically formulated as a Markov decision process (MDP). At every time step,   \n134 $t = 1 , 2 , \\dots$ , the agent observes the environment’s state $s _ { t } \\in S$ , and uses it to select an action $a _ { t } \\in { \\mathcal { A } }$   \n135 As a consequence, the agent receives a reward $r _ { t } \\in \\mathcal { R } \\subset \\mathbb { R }$ and the environment transitions to the state   \n136 $s _ { t + 1 }$ . The tuple $\\left( { { s _ { t + 1 } } , { r _ { t } } } \\right)$ is sampled from the static probability distribution $p : { \\mathcal { S } } \\times { \\mathcal { A } }  { \\mathcal { P } } ( S \\times { \\mathcal { R } } )$   \n137 whilst the actions $a _ { t }$ are sampled from the parametric policy function $\\pi _ { \\theta } : { \\mathcal { S } }  { \\mathcal { P } } ( { \\mathcal { A } } )$ : ",
+        "bbox": [
+            140,
+            753,
+            825,
+            838
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7604fa488e2a26f15fefbc1dd4c0df86e273242ce6180e2671ae66935a2fac77.jpg",
+        "text": "$$\ns _ { t + 1 } , r _ { t } \\sim p ( s _ { t + 1 } , r _ { t } | s _ { t } , a _ { t } ) , \\quad a _ { t } \\sim \\pi _ { \\theta } ( a _ { t } | s _ { t } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            844,
+            653,
+            862
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "138 The goal of the agent is to find the optimal policy parameters $\\theta ^ { * }$ that maximise the expected return   \n139 $\\bar { R } = \\mathbb { E } [ \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } r _ { t } ]$ , where $\\gamma$ is the discount factor. In the more general framework, the state is   \n140 only partially observable, meaning that the agent can not directly observe the state but instead it   \n141 observes $o _ { t } \\in \\mathcal { O }$ which is typically given by a function of the state. In this situation, the environment   \n142 is modelled by a partial observable Markov decision process (POMDP) and the policy usually   \n143 incorporates past history $h _ { t } = a _ { 0 } o _ { 0 } r _ { 0 } , \\ldots , a _ { t - 1 } o _ { t - 1 } r _ { t - 1 }$ .   \n144 Q-Learning and Deep Q-Networks The action-value function $Q ^ { \\pi }$ gives the estimated return when   \n145 the agent has the state history $h _ { t }$ , executes action $a _ { t }$ and follows the policy $\\pi$ on the future time   \n146 steps. It can be recursively defined by $Q ^ { \\pi } ( h _ { t } , a _ { t } ) = \\mathbb { E } _ { s _ { t + 1 } , r _ { t } \\sim p } \\big [ r _ { t } + \\gamma \\mathbb { E } _ { a _ { t + 1 } \\sim \\pi } \\big [ Q ^ { \\pi } ( h _ { t + 1 } , a _ { t + 1 } ) \\big ] \\big ]$ . Q  \n147 learning and Deep Q-Networks (DQN) [25] are popular methods for obtaining the optimal action value   \n148 function $Q ^ { * }$ . Once we have $Q ^ { * }$ , the optimal policy is also available as $\\pi ^ { * } = \\arg \\operatorname* { m a x } _ { a _ { t } } Q ^ { * } ( h _ { t } , a _ { t } )$ .   \n149 In DQN, the action-value function is approximated by a deep NN with parameters $\\theta$ . $Q _ { \\theta } ^ { * }$ is found by   \n150 minimising the loss function: ",
+        "bbox": [
+            142,
+            868,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            90,
+            825,
+            135
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            147,
+            826,
+            244
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/41948c81d6af6371941d2937b70ac7b6f567c6cde8d6c5c78f4a99f75db8f0ac.jpg",
+        "text": "$$\n\\mathcal { L } _ { t } ( \\theta ) = \\mathbb { E } _ { h _ { t } , a _ { t } , r _ { t } , h _ { t + 1 } } [ ( y _ { t } - Q _ { \\theta } ^ { \\pi } ( h _ { t } , a _ { t } ) ) ^ { 2 } ] , \\quad \\mathrm { w h e r e ~ } y _ { t } = r _ { t } + \\gamma \\operatorname* { m a x } _ { a ^ { \\prime } } Q _ { \\theta ^ { \\prime } } ^ { \\pi } ( a _ { t + 1 } , h _ { t + 1 } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            200,
+            248,
+            776,
+            271
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where 151 $\\pi$ is the $\\epsilon$ -greedy policy which takes action arg $\\operatorname* { m a x } _ { a _ { t } } Q ^ { \\pi } ( a _ { t } , h _ { t } )$ with probability $1 - \\epsilon$ , and 152 takes a random action with probability $\\epsilon$ . $\\theta ^ { \\prime }$ are the parameters of a target network that are periodically 153 copied from $\\theta$ and kept constant for a number of iterations. ",
+        "bbox": [
+            140,
+            277,
+            831,
+            320
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "154 Multi-Agent Reinforcement Learning In this work, we consider the MARL setting where the   \n155 underlying environment is modelled by a partially observable stochastic game [13]. In this setting,   \n156 the environment is populated by multiple agents which have individual observations and rewards and   \n157 act according to individual policies. Their goal is to maximise their own expected return. ",
+        "bbox": [
+            142,
+            334,
+            825,
+            391
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "158 4 Evolution via Evolutionary Reward ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            409,
+            503,
+            428
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "159 In this section, we propose a reward function that enables RL algorithms to search for policies with   \n160 increasingly evolutionary success. We call this reward the evolutionary reward because it is always   \n161 aligned with the fitness function. We also propose a specific RL algorithm that is particularly suited   \n162 to maximise the evolutionary reward in open-ended evolutionary environments however other RL   \n163 algorithms could also be used.   \n164 Evolutionary reward The evolutionary reward of an agent is proportional to the number of copies   \n165 its genes have in the world’s population. Maximising this reward leads to the maximisation of the   \n166 survival and reproduction success of the genes an agent carries. We start by defining the kinship   \n167 function between a pair of agents $i$ and $j$ , who carry $N$ genes represented by the integer vectors $g ^ { i }$   \n168 and $g ^ { j }$ (we chose to use $\\textbf {  { g } }$ for genome, which in biology is the set of genes an agent carries): ",
+        "bbox": [
+            140,
+            440,
+            825,
+            511
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            523,
+            825,
+            594
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c75c7d8a5d7f8a06b2478eb32b774abd02713ebcf24a2c8deaedd34f2da7bd5a.jpg",
+        "text": "$$\nk \\colon \\mathbb { Z } ^ { N } \\times \\mathbb { Z } ^ { N } \\to [ 0 , 1 ] , \\qquad k ( g ^ { i } , g ^ { j } ) = \\frac { 1 } { N } \\sum _ { p = 1 } ^ { N } \\delta _ { g _ { p } ^ { i } , g _ { p } ^ { j } } \\quad ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            599,
+            686,
+            643
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "169 where $\\delta _ { g _ { p } ^ { i } , g _ { p } ^ { j } }$ is the Kronecker delta which is one if $g _ { p } ^ { i } = g _ { p } ^ { j }$ and zero otherwise. When agent $i$ is alive   \n170 at time $t + 1$ , it receives the reward: ",
+        "bbox": [
+            142,
+            648,
+            828,
+            683
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/215973ffd3bbb3990833d808aff810ed7eb97540a9d9db0d7606e1fd4e04e872.jpg",
+        "text": "$$\nr _ { t } ^ { i } = \\sum _ { j \\in \\mathcal { A } _ { t + 1 } } k ( \\pmb { g } ^ { i } , \\pmb { g } ^ { j } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            685,
+            573,
+            722
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "171 where $\\boldsymbol { \\mathcal { A } } _ { t + 1 }$ is the set of agents alive at the instant $t + 1$ . Note that since agent $i$ is alive at $t + 1$ ,   \n172 $\\boldsymbol { \\mathcal { A } } _ { t + 1 }$ includes agent $i$ . $T ^ { i } - 1$ is the last time step that agent $i$ is alive and so, at this instant, the agent   \n173 receives its final reward which is proportional to the discounted sum of the number of times its genes   \n174 will be present on other agents after its death: ",
+        "bbox": [
+            140,
+            727,
+            825,
+            782
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2df4af15ece419a31a7cf323283f9c3b23e19b52dfeebc80f62e4579e832dfa2.jpg",
+        "text": "$$\nr _ { T ^ { i } - 1 } ^ { i } = \\sum _ { t = T ^ { i } } ^ { \\infty } \\gamma ^ { t - T ^ { i } } \\sum _ { j \\in { \\mathcal A } _ { t } } k ( { \\boldsymbol g } ^ { i } , { \\boldsymbol g } ^ { j } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            787,
+            617,
+            830
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "175 with this reward function, the agents are incentivised to maximise the survival and replication success   \n176 of the genes they carry. In the agent-centered view, the agents are incentivised to survive and replicate,   \n177 but also to help their family (kin) survive and replicate; and to make sure that when they die their   \n178 family is in a good position to carry on surviving and replicating. The degree of collaboration with   \n179 other family members depends on the overlap between their genotype as it happens in nature.   \n180 The discount factor, $\\gamma$ , needs to be in the interval $[ 0 , 1 [$ to ensure the final reward remains bounded.   \n181 Due to the exponential discounting we can compute the final reward up to an error of $\\epsilon$ by summing   \n182 over a finite period of time denoted by the effective horizon $( h _ { e } )$ . To see how to compute the $h _ { e }$ for   \n183 a given environment and $\\epsilon$ see the Appendix G.1. By computing the final reward this way, we can   \n184 now use RL algorithms like Q-learning to train agents with this evolutionary reward. However, in the   \n185 next section we introduce a more practical algorithm that allows us to estimate the final reward more   \n186 efficiently.   \n187 Evolutionary Value-Decomposition Networks We propose Evolutionary Value-Decomposition   \n188 Networks (E-VDN) as an extension of VDN [38] (explained in the Appendix D) from the binary   \n189 cooperative setting with static teams to the continuous cooperative setting with dynamic families.   \n190 E-VDN helps us reduce the variance of the value estimation and allows us to estimate the final   \n191 evolutionary reward without having to simulate the environment forward for $h _ { e }$ iterations.   \n192 Within a team, each agent fully cooperates with all the other members of the team, and it does not   \n193 cooperate at all with any agent outside of the team. Moreover, if $a$ and $b$ are members of the same   \n194 team and $c$ is a member of $a$ ’s team then $c$ and $b$ are also in the same team. Within a family, the   \n195 degrees of cooperation amongst its members depends on their kinship degree (which can be any real   \n196 number from 0 to 1). Also, if $a$ and $b$ are members of the same family and $c$ is part of $a$ ’s family, $c$ is   \n197 not necessarily part of $b$ ’s family.   \n198 Each agent $i$ sees the members of its family from an unique perspective, based on the kinship degree it   \n199 shares with them. In E-VDN, each agent $i$ has a joint action-value function, $Q ^ { i }$ . E-VDN assumes $Q ^ { i }$   \n200 can be composed by averaging the action-value functions across the members of $i$ ’s family weighted   \n201 by their kinship with agent $i$ (this is similar to the VDN’s assumption): ",
+        "bbox": [
+            140,
+            842,
+            825,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            90,
+            825,
+            189
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            202,
+            825,
+            272
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            277,
+            825,
+            363
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            367,
+            825,
+            424
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8b41e11bcc82629ea8d98135c4a99e6130bba08758007669568e2b643d213fd6.jpg",
+        "text": "$$\nQ ^ { i } ( ( h _ { t } ^ { 1 } , h _ { t } ^ { 2 } , \\dots , h _ { t } ^ { | { \\cal A } _ { t } | } ) , ( a _ { t } ^ { 1 } , a _ { t } ^ { 2 } , \\dots , a _ { t } ^ { | { \\cal A } _ { t } | } ) ) \\approx \\frac { 1 } { n _ { t } ^ { i } } \\sum _ { j \\in { \\cal A } _ { t } } k ( g ^ { i } , g ^ { j } ) \\tilde { Q } ^ { j } ( h _ { t } ^ { j } , a _ { t } ^ { j } | \\tilde { \\theta } _ { j } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            238,
+            428,
+            758,
+            467
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "202 where $n _ { t } ^ { i }$ is a normalisation coefficient defined as $\\begin{array} { r } { n _ { t } ^ { i } = \\sum _ { j \\in \\mathcal { A } _ { t } } k ( \\pmb { g } ^ { i } , \\pmb { g } ^ { j } ) , \\tilde { Q } _ { t } ^ { j } } \\end{array}$ is the output of a NN   \n203 with parameters $\\widetilde { \\theta } _ { j }$ and with the input $( h _ { t } ^ { j } , a _ { t } ^ { j } )$ . Composing $Q ^ { i }$ with an average, instead of a sum   \n204 as it happens in VDN, is necessary as E-VDN allows the number of value functions contributing to   \n205 the composition to vary as the family gets bigger or smaller (agents born and die). This averaging   \n206 allows us to incorporate the local observations of each family member and reduce variance in the   \n207 value estimation.   \n208 More importantly, E-VDN allows us to deal with the difficulty of estimating the final reward (5) in a   \n209 particularly convenient way. As is clear from its definition (5), the final reward is the expected sum   \n210 (over time) of kinship that agent $i$ has with other agents $j$ after its death. The key idea is to note that   \n211 this value $( r _ { T ^ { i } - 1 } ^ { i } )$ can be approximated by the Q-value of other agents $j$ that are close to (have high   \n212 kinship with) agent $i$ : ",
+        "bbox": [
+            140,
+            470,
+            825,
+            561
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            566,
+            825,
+            637
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5686a8f09d104b58474f74829312f6bed4bc49487c3705807423d78ed37acaff.jpg",
+        "text": "$$\n\\hat { r } _ { T ^ { i } - 1 } ^ { i } = \\left\\{ \\begin{array} { l l } { \\frac { 1 } { n _ { T ^ { i } } ^ { i } } \\sum _ { j \\in \\mathcal { A } _ { T ^ { i } } } k ( g ^ { i } , g ^ { j } ) \\tilde { Q } _ { T ^ { i } } ^ { j } ( \\dots ) \\approx Q _ { T ^ { i } } ^ { i } ( \\dots ) } & { \\mathrm { i f ~ } n _ { T ^ { i } } ^ { i } > 0 } \\\\ { 0 } & { \\mathrm { i f ~ } n _ { T ^ { i } } ^ { i } = 0 } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            258,
+            640,
+            732,
+            683
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "213 The final reward is zero if, and only if, at the time of its death the agent has no surviving family. ",
+        "bbox": [
+            138,
+            685,
+            799,
+            702
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Each 214 $\\tilde { Q } _ { t } ^ { i }$ is trained by back-propagating gradients, $g _ { t } ^ { i }$ , from the Q-learning rule: ",
+        "bbox": [
+            142,
+            708,
+            696,
+            724
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/33a6beef3ebd5518ab2a21796882924c6207298e40341a728e4385e4fa70dddd.jpg",
+        "text": "$$\ng _ { t } ^ { i } = \\nabla \\pmb { \\theta } _ { i } ( y _ { t } ^ { i } - \\frac { 1 } { n _ { t } ^ { i } } \\sum _ { j \\in \\cal A _ { t } } k ( \\pmb { g } ^ { i } , \\pmb { g } ^ { j } ) \\tilde { Q } ^ { j } ( h _ { t } ^ { j } , a _ { t } ^ { j } | \\tilde { \\pmb { \\theta } } _ { j } ) ) ^ { 2 } \\approx \\nabla \\pmb { \\theta } _ { i } ( y _ { t } ^ { i } - Q _ { t } ^ { i } ( \\dots | \\pmb { \\theta } _ { i } ) ) ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            243,
+            727,
+            753,
+            766
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where 215 $\\theta _ { i }$ is the concatenation of all the parameters $\\widetilde { \\theta } _ { j }$ , used in each $\\tilde { Q } ^ { j }$ , contributing to the estimation 216 of $Q ^ { i }$ ; i.e. $\\pmb { \\theta } _ { i } : = \\{ \\widetilde { \\theta } _ { j } \\} _ { j }$ s.t. $k ( { \\pmb g } ^ { i } , { \\pmb g } ^ { j } ) > 0$ . Note that $\\tilde { Q } ^ { i }$ are neural networks with parameters $\\widetilde { \\theta } _ { i }$ and $Q ^ { i }$ is 217 simply the average stated in (6). ",
+        "bbox": [
+            140,
+            770,
+            823,
+            818
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The learning targets 218 $y _ { t } ^ { i }$ are given by: ",
+        "bbox": [
+            142,
+            823,
+            413,
+            839
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a5e3d1acfcd0413b033417bd84b17b5f038c8e724533e84178d2308bb0320a98.jpg",
+        "text": "$$\n\\begin{array} { r } { y _ { t } ^ { i } = \\left\\{ \\begin{array} { l l } { r _ { t } ^ { i } + \\gamma \\operatorname* { m a x } _ { { \\pmb a } _ { t + 1 } } Q _ { t + 1 } ^ { i } ( . . . ) | \\pmb \\theta _ { i } ^ { \\prime } ) } & { \\mathrm { i f ~ } t < T ^ { i } - 1 } \\\\ { \\hat { r } _ { T ^ { i } - 1 } ^ { i } } & { \\mathrm { i f ~ } t = T ^ { i } - 1 } \\end{array} \\right. , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            307,
+            842,
+            684,
+            877
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "219 $r _ { t } ^ { i }$ is the evolutionary reward (4), $\\hat { r } _ { T ^ { i } - 1 } ^ { i }$ is the estimate of the final evolutionary reward (7) and $\\theta _ { i } ^ { \\prime }$   \n220 are the parameters of the target network that get periodically copied from $\\theta _ { i }$ . We don’t use a replay   \n221 buffer in our training (which is commonly used in DQN) due to the non-stationary of multi-agent   \n222 environments (more about this in the Appendix G.2). ",
+        "bbox": [
+            137,
+            881,
+            826,
+            912
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/aee2170b9b17f34f89c3137d615986a64df5b506af473a58a2040f54f5ee1896.jpg",
+        "image_caption": [
+            "Figure 1: The binary environment. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            254,
+            89,
+            743,
+            247
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            148,
+            296,
+            825,
+            325
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Since the joint action-value $Q ^ { i }$ increases monotonically with increasing $\\tilde { Q } ^ { i }$ , an agent acting greedily with respect to its action-value function will also act greedily in respect to its family action-value function: arg m $\\begin{array} { r } { \\operatorname { 1 a x } _ { a _ { t } ^ { i } } Q _ { t } ^ { i } ( . . . ) \\approx \\arg \\operatorname* { m a x } _ { a _ { t } ^ { i } } \\tilde { Q } ^ { i } ( h _ { t } ^ { i } , a _ { t } ^ { i } ) . } \\end{array}$ . ",
+        "bbox": [
+            169,
+            332,
+            823,
+            378
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 Experimental Setup ",
+        "text_level": 1,
+        "bbox": [
+            166,
+            396,
+            372,
+            414
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We want to test two hypotheses: 1) E-VDN is particularly well suited to make agents climb the fitness landscape in open-ended evolutionary environments; 2) E-VDN is able to increase the evolutionary fitness of agents in non-binary cooperative environments. To test the first hypothesis we need to compare E-VDN with another popular evolutionary algorithm. To make it easier to implement the competing algorithm we are going to use a binary cooperative environment to test the first hypothesis. To test the second hypothesis we will use a non-binary cooperative environment. Note, if an agent carries more than one gene (like it happens in nature) we have a non-binary environment. ",
+        "bbox": [
+            165,
+            428,
+            825,
+            525
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "234 In this section, we give a quick overview of these two multi-agent environments, as well as details   \n235 of the network architectures and the training regime. For a more complete description of the   \n236 environments, you can refer to the Appendix E. In the binary environment, we compared our   \n237 algorithm with a popular Evolution Strategies algorithm (CMA-ES [14]), and describe the training   \n238 regime used for CMA-ES in the Appendix F. ",
+        "bbox": [
+            142,
+            531,
+            825,
+            602
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The Binary Environment The binary environment is a 2-dimensional grid world, which is initialised with five agents carrying five unique genomes (Figure 1). At each time step, each agent may move one step and produce an attack to another agent in an adjacent tile. When an agent moves to a tile with food it collects all the food available in it. If an agent chooses to produce an attack, it decreases its victim’s health by one point, if the victim’s health reaches zero it dies and $50 \\%$ of its collected food is captured by the attacker. The food is used to survive (one unit of food must be consumed every time step to remain alive), and to reproduce. When agents are within their fertile age and they have stored enough food, they reproduce themselves asexually and give birth to an agent carrying an exact copy of their genome. Each genome has only a single gene and there are no mutations. These rules make the cooperation between agents binary, agents either fully-cooperate (they have the exact same genome) or they don’t cooperate at all (their genome has no overlap). ",
+        "bbox": [
+            168,
+            617,
+            825,
+            770
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The Non-binary Environment The non-binary environment has the same rules as the binary environment with the difference that the agents now have 32 genes in their genome and they reproduce sexually instead of asexually. When two fertile agents are adjacent, they give birth to an agent who’s genome is composed by two halves of the genes of each parent, selected randomly. There are no genders, any agent can reproduce with any other agent. These rules give rise to different levels of collaboration: from 0 to 1 in steps of $\\frac { 1 } { 3 2 }$ . ",
+        "bbox": [
+            173,
+            784,
+            825,
+            869
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "256 Policy Each agent observes a 5x5 square crop of the surrounding state (Figure 1). The agent   \n257 sees six features for every visible tile; i.e. the input is a 5x5x6 tensor. This includes two features   \n258 corresponding to tile properties (food available and whether it is occupied or not) and four features   \n259 corresponding to the occupying agents’ properties (age, food stored, kinship and health). Besides   \n260 these local inputs, each agent also observes its absolute position, family size and the total number   \n261 of agents in the world. We intend to remove these extra inputs in future work as we provide agents   \n262 with memory (we’re currently providing our policy with $\\hat { o _ { t } ^ { i } }$ instead of $h _ { t } ^ { i \\cdot }$ ). The NN has ten outputs   \n263 (five movement actions with no attack and five movement actions with an attack). In this work, we   \n264 used two different feed forward architectures: one is simply a fully connected NN with three hidden   \n265 layers and 244, 288 parameters in total, the other architecture is composed by convolutional and   \n266 dense layers and it is much smaller containing only 23, 616 parameters. The smaller NN was used to   \n267 compare our algorithm with an evolutionary algorithm which doesn’t scale well to larger networks. ",
+        "bbox": [
+            148,
+            883,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            90,
+            825,
+            229
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Training details In this work, the genome does not directly encode the policy, however, we think it would be interesting to do that in future work. In the binary environment, we train five different policies (with the same architecture but different weights) simultaneously. At each training episode, we sample five policies with replacement and assign each one to one of the five unique genomes. We do this, to force each policy to interact with all other policies (including itself), increasing their robustness in survival and reproduction. During the test episodes, no sampling occurs, each policy is simply assigned to each unique genome. The training episodes had a length between 450 and 550 (note that the reward is computed as if there was no episode end), and the test episodes had a length of 500 steps. ",
+        "bbox": [
+            161,
+            244,
+            825,
+            371
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "277 In the non-binary environment, due to the large number of unique genomes, it is unfeasible to assign   \n278 a unique policy to each unique genome. To keep things simple, we chose to use only one policy in   \n279 this environment. This was not possible to do with CMA-ES, so we did not implement it in this   \n280 environment (more about CMA-ES on Appendix F). ",
+        "bbox": [
+            142,
+            376,
+            825,
+            433
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Traits encoded by the genes In the non-binary environment, we can think of each of the 32 genes to change some visual feature (e.g. facial feature) of their agent so that it can be better recognised by its family. In the binary environment, besides the gene encoding this visual feature it also encodes which policy, chosen from a set of 5 policies, the agent is going to have. Note that the genes encode fixed traits (they don’t change during an agent’s lifetime) and their frequency in the population evolve through normal evolution (death and birth). With EvER we don’t need evolution to create the reward function and continuously align it with the fitness function. The agent’s brain is always trying to learn the right things for the survival of its genes, however, the actual genes are evolving at the normal pace of evolution. ",
+        "bbox": [
+            171,
+            448,
+            825,
+            573
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "290 To analyse the impact of our reward function, we deliberately chose to minimise entanglement   \n291 between genes and other aspects of the agents. However, EvER can be easily used in environments   \n292 where genes encode more traits like the agent’s abilities, visual features, initial weights and the   \n293 topology of its policy. ",
+        "bbox": [
+            143,
+            579,
+            823,
+            636
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Evaluation Metrics In our simple environments, fitter policies can use the environment resources more efficiently and increase their population size to larger numbers. Therefore, to evaluate the performance of the algorithms in generating increasingly fitter species we track the average population size along training time. ",
+        "bbox": [
+            174,
+            651,
+            823,
+            707
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6 Results ",
+        "text_level": 1,
+        "bbox": [
+            169,
+            727,
+            266,
+            743
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Training agents with E-VDN generates quite an interesting evolutionary history. Throughout the binary environment history, we found four distinct eras where agents engage in significantly distinct behaviour patterns $1 ^ { \\mathrm { s t } }$ row of fig. 2). In the first era (the blue line - which lasts only a few hundred iterations), the agents learned how to survive, and through their encounters with the other founding agents, they have learnt that it was always (evolutionary) advantageous to attack other agents. In the second era (orange line), the agents’ food-gathering skills increased to a point where they started to reproduce. In this era, the birth-rate and population numbers increased fast. However, with the extra births, intra-family encounters became more frequent, and intra-family violence rose to its all-time maximum driving the average life span down. This intra-family violence quickly decreased in the third era (green line), as agents started to recognize their kin. Kin detection allowed for selective kindness and selective violence, which took the average life span to its all-time maximum. Finally, ",
+        "bbox": [
+            173,
+            758,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/dad021ed60b9287668f6b891462ea1be5b4857570da1ab99901c11e6391b439b.jpg",
+        "image_caption": [
+            "Figure 2: ( $1 ^ { \\mathrm { s t } }$ row) Results obtained using E-VDN with the larger NN, each point was obtained by averaging 20 test episodes. The different colours correspond to different eras. This plot was generated with a denser version of the evolutionary reward (more details on the Appendix G.3). $2 ^ { \\mathrm { n d } }$ row) Results obtained using CMA-ES and E-VDN algorithms with the smaller NN and the standard evolutionary reward (4). Both algorithms were trained with 20 CPUs each. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            90,
+            821,
+            250
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "310 in the fourth era (red line), agents learned how to sacrifice their lives for the future of their family.   \n311 Old infertile agents started allowing the younger generation to eat them without retaliation. Through   \n312 this cannibalism, the families had found a system for wealth inheritance. A smart allocation of the   \n313 family’s food resources in the fitter generation led to an increase in the population size with the cost   \n314 of a shorter life span. This behaviour emerges because the final reward (5) incentivises agents to   \n315 plan for the success of their genes even after their death. This behaviour is further investigated in   \n316 the Appendix H.1. These results show that optimising open-ended evolutionary environments with   \n317 E-VDN does indeed generate increasingly complex behaviours.   \n318 The $2 ^ { \\mathrm { n d } }$ row of Figure 2, shows the macro-statistics obtained by training the smaller NN with CMA  \n319 ES and E-VDN. From the figure, we observe that E-VDN is able to produce a larger population of   \n320 agents with a longer life-span and a higher birth rate. A small population means that many resources   \n321 are left unused by the current population, this creates an opportunity for a new and more efficient   \n322 species to collect the unused resources and multiply its numbers. These opportunities are present in   \n323 the CMA-ES environment, however the algorithm could not find them, which suggests that E-VDN   \n324 is better at finding the way up the fitness landscape than CMA-ES. Video 1, shows that each family   \n325 trained with CMA-ES creates a swarm formation in a line that moves around the world diagonally.   \n326 When there is only one surviving family, this simple strategy allows agents to only step into tiles   \n327 that have reached their maximum food capacity. However, this is far from an evolutionarily stable   \n328 strategy [35] (ESS; i.e. a strategy that is not easily driven to extinction by a competing strategy), as   \n329 we verify when we place the best two families trained with CMA-ES on the same environment as the   \n330 best two E-VDN families and observe the CMA-ES families being consistently driven quickly to   \n331 extinction by their competition (fig. 4.a of Appendix B).   \n332 Our results, in the non-binary environment, show that in a non-binary cooperative setting E-VDN   \n333 also improves the ability of the trained policy to survive and replicate its genes (Figure 4.b,c and d   \n334 of Appendix B). This is a key feature that evolutionary algorithms should have in order to take the   \n335 research in open-ended evolutionary environments further. Note, that the non-binary environment   \n336 is much harder than the binary one. To replicate, agents need to be adjacent to other agents. In the   \n337 beginning, all agents are unrelated making it dangerous to get adjacent to another agent as it often   \n338 leads into attacks, but it is also dangerous to get too far away from them since with a limited vision it   \n339 is hard to find a fertile mate once they lose sight of each other. Video 2 shows a simulation of the   \n340 evolved policy being run on the non-binary environment, it seems that agents found a way to find   \n341 mates by moving to a certain region of the map (the breeding ground) once they are fertile. ",
+        "bbox": [
+            140,
+            358,
+            825,
+            469
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            138,
+            476,
+            825,
+            670
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            675,
+            825,
+            814
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "42 7 Conclusion & Future Work ",
+        "text_level": 1,
+        "bbox": [
+            153,
+            835,
+            433,
+            853
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "43 This paper has introduced an evolutionary reward function that when maximised also maximises the   \n44 evolutionary fitness of the agent. This allows RL to be used as a tool for research of open-ended   \n345 evolutionary systems. To implement this reward function, we extended the concept of team to the   \n346 concept of family and introduce continuous degrees of cooperation. Future work could explore three   \n347 directions: 1) Explore a different reward function that makes agents maximise the expected geometric   \n348 growth rate of their genes; 2) Research the minimum set of requirements to emerge natural cognitive   \n349 abilities in artificial agents such as identity awareness and recognition, friendship and hierarchical   \n350 status (by following our proposed methodology for progress in AI (Appendix ??)) 3) Extend the use   \n351 of genes to encode more fixed traits in the agent like its initial weights and the topology of its policy. ",
+        "bbox": [
+            148,
+            869,
+            823,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            92,
+            825,
+            175
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "352 Broader Impact ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            90,
+            310,
+            107
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Simulating the key processes that generated life and intelligence in nature is a promising path to further our understanding in this field and unlock ever more intelligent algorithms able to solve useful problems for the world. However, embodying AI with the goal to survive and self-reproduce can be dangerous, and should never be done outside of a sand-boxed environment. ",
+        "bbox": [
+            174,
+            121,
+            825,
+            176
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            196,
+            266,
+            212
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] David Ackley and Michael Littman. Interactions between learning and evolution. Artificial life II, 10:487–509, 1991.   \n[2] BURT Austin, Robert Trivers, and Austin Burt. Genes in conflict: the biology of selfish genetic elements. Harvard University Press, 2009.   \n[3] Trapit Bansal, Jakub Pachocki, Szymon Sidor, Ilya Sutskever, and Igor Mordatch. Emergent complexity via multi-agent competition. arXiv preprint arXiv:1710.03748, 2017.   \n[4] Christopher Berner, Greg Brockman, Brooke Chan, Vicki Cheung, Przemysław D˛ebiak, Christy Dennison, David Farhi, Quirin Fischer, Shariq Hashme, Chris Hesse, et al. Dota 2 with large scale deep reinforcement learning. arXiv preprint arXiv:1912.06680, 2019.   \n[5] Wendelin Böhmer, Vitaly Kurin, and Shimon Whiteson. Deep coordination graphs. arXiv preprint arXiv:1910.00091, 2019. [6] Richard Dawkins. The selfish gene. 1976.   \n[7] Richard Dawkins. Twelve misunderstandings of kin selection. Zeitschrift für Tierpsychologie, 51(2):184–200, 1979.   \n[8] Stefan Elfwing, Eiji Uchibe, Kenji Doya, and Henrik I Christensen. Co-evolution of shaping rewards and meta-parameters in reinforcement learning. Adaptive Behavior, 16(6):400–412, 2008.   \n[9] Jakob N Foerster, Gregory Farquhar, Triantafyllos Afouras, Nantas Nardelli, and Shimon Whiteson. Counterfactual multi-agent policy gradients. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018.   \n[10] Andy Gardner and Francisco Úbeda. The meaning of intragenomic conflict. Nature ecology & evolution, 1(12):1807–1815, 2017.   \n[11] Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pages 2672–2680, 2014.   \n[12] Carlos Guestrin, Daphne Koller, and Ronald Parr. Multiagent planning with factored mdps. In Advances in neural information processing systems, pages 1523–1530, 2002.   \n[13] Eric A Hansen, Daniel S Bernstein, and Shlomo Zilberstein. Dynamic programming for partially observable stochastic games. In AAAI, volume 4, pages 709–715, 2004.   \n[14] Nikolaus Hansen, Sibylle D Müller, and Petros Koumoutsakos. Reducing the time complexity of the derandomized evolution strategy with covariance matrix adaptation (cma-es). Evolutionary computation, 11(1):1–18, 2003.   \n[15] Nikolaus Hansen, Youhei Akimoto, and Petr Baudis. CMA-ES/pycma on Github. Zenodo, DOI:10.5281/zenodo.2559634, February 2019. URL https://doi.org/10.5281/zenodo. 2559634.   \n[16] Verena Heidrich-Meisner and Christian Igel. Evolution strategies for direct policy search. In International Conference on Parallel Problem Solving from Nature, pages 428–437. Springer, 2008. ",
+        "bbox": [
+            161,
+            205,
+            828,
+            919
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "96 [17] Verena Heidrich-Meisner and Christian Igel. Variable metric reinforcement learning methods applied to the noisy mountain car problem. In European Workshop on Reinforcement Learning, pages 136–150. Springer, 2008. [18] Verena Heidrich-Meisner and Christian Igel. Hoeffding and bernstein races for selecting policies in evolutionary direct policy search. In Proceedings of the 26th Annual International Conference on Machine Learning, pages 401–408. ACM, 2009. [19] Jelle R Kok, Eter Jan Hoen, Bram Bakker, and Nikos Vlassis. Utile coordination: Learning interdependencies among cooperative agents. In EEE Symp. on Computational Intelligence and Games, Colchester, Essex, pages 29–36, 2005. [20] Karol Kurach, Anton Raichuk, Piotr Stanczyk, Michał Zaj ˛ac, Olivier Bachem, Lasse Espeholt, ´ Carlos Riquelme, Damien Vincent, Marcin Michalski, Olivier Bousquet, et al. Google research football: A novel reinforcement learning environment. arXiv preprint arXiv:1907.11180, 2019. [21] Richard L Lewis, Satinder Singh, and Andrew G Barto. Where do rewards come from? In Proceedings of the International Symposium on AI-Inspired Biology, pages 2601–2606, 2010. [22] Ryan Lowe, Yi Wu, Aviv Tamar, Jean Harb, OpenAI Pieter Abbeel, and Igor Mordatch. Multiagent actor-critic for mixed cooperative-competitive environments. In Advances in Neural Information Processing Systems, pages 6379–6390, 2017. [23] Simon M Lucas and Thomas P Runarsson. Temporal difference learning versus co-evolution for acquiring othello position evaluation. In 2006 IEEE Symposium on Computational Intelligence and Games, pages 52–59. IEEE, 2006. [24] Simon M Lucas and Julian Togelius. Point-to-point car racing: an initial study of evolution versus temporal difference learning. In 2007 iEEE symposium on computational intelligence and games, pages 260–267. IEEE, 2007. [25] Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529, 2015. [26] Frans A. Oliehoek and Christopher Amato. A Concise Introduction to Decentralized POMDPs. SpringerBriefs in Intelligent Systems. Springer, May 2016. doi: 10.1007/978-3-319-28929-8. URL http://www.fransoliehoek.net/docs/OliehoekAmato16book.pdf. [27] Frans A Oliehoek, Shimon Whiteson, Matthijs TJ Spaan, et al. Approximate solutions for factored dec-pomdps with many agents. In AAMAS, pages 563–570, 2013. [28] Tabish Rashid, Mikayel Samvelyan, Christian Schroeder De Witt, Gregory Farquhar, Jakob Foerster, and Shimon Whiteson. Qmix: monotonic value function factorisation for deep multi-agent reinforcement learning. arXiv preprint arXiv:1803.11485, 2018. [29] Craig W Reynolds. Competition, coevolution and the game of tag. In Proceedings of the Fourth International Workshop on the Synthesis and Simulation of Living Systems, pages 59–69, 1994. [30] Thomas Philip Runarsson and Simon M Lucas. Coevolution versus self-play temporal difference learning for acquiring position evaluation in small-board go. IEEE Transactions on Evolutionary Computation, 9(6):628–640, 2005. [31] David Silver, Thomas Hubert, Julian Schrittwieser, Ioannis Antonoglou, Matthew Lai, Arthur Guez, Marc Lanctot, Laurent Sifre, Dharshan Kumaran, Thore Graepel, et al. A general reinforcement learning algorithm that masters chess, shogi, and go through self-play. Science, 362(6419):1140–1144, 2018. [32] Karl Sims. Evolving 3d morphology and behavior by competition. Artificial life, 1(4):353–372, 1994. [33] Satinder Singh, Richard L Lewis, Andrew G Barto, and Jonathan Sorg. Intrinsically motivated reinforcement learning: An evolutionary perspective. IEEE Transactions on Autonomous Mental Development, 2(2):70–82, 2010. ",
+        "bbox": [
+            153,
+            56,
+            830,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[34] J Maynard Smith. Group selection and kin selection. Nature, 201(4924):1145, 1964. ",
+        "bbox": [
+            160,
+            90,
+            766,
+            107
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[35] J Maynard Smith and George R Price. The logic of animal conflict. Nature, 246(5427):15, 1973. ",
+        "bbox": [
+            179,
+            114,
+            823,
+            145
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[36] Kenneth O Stanley and Risto Miikkulainen. Evolving neural networks through augmenting topologies. Evolutionary computation, 10(2):99–127, 2002. ",
+        "bbox": [
+            179,
+            152,
+            823,
+            181
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[37] Joseph Suarez, Yilun Du, Phillip Isola, and Igor Mordatch. Neural mmo: A massively multiagent game environment for training and evaluating intelligent agents. arXiv preprint arXiv:1903.00784, 2019. ",
+        "bbox": [
+            176,
+            190,
+            823,
+            233
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[38] Peter Sunehag, Guy Lever, Audrunas Gruslys, Wojciech Marian Czarnecki, Vinicius Zambaldi, Max Jaderberg, Marc Lanctot, Nicolas Sonnerat, Joel Z Leibo, Karl Tuyls, et al. Valuedecomposition networks for cooperative multi-agent learning. arXiv preprint arXiv:1706.05296, 2017. ",
+        "bbox": [
+            174,
+            242,
+            825,
+            297
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[39] Richard S Sutton, Andrew G Barto, et al. Introduction to reinforcement learning, volume 2. MIT press Cambridge, 1998. ",
+        "bbox": [
+            173,
+            306,
+            823,
+            337
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[40] Elise Van der Pol and Frans A Oliehoek. Coordinated deep reinforcement learners for traffic light control. Proceedings of Learning, Inference and Control of Multi-Agent Systems (at NIPS 2016), 2016. ",
+        "bbox": [
+            176,
+            344,
+            823,
+            387
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[41] Oriol Vinyals, Igor Babuschkin, Wojciech M Czarnecki, Michaël Mathieu, Andrew Dudzik, Junyoung Chung, David H Choi, Richard Powell, Timo Ewalds, Petko Georgiev, et al. Grandmaster level in starcraft ii using multi-agent reinforcement learning. Nature, 575(7782):350–354, 2019. ",
+        "bbox": [
+            179,
+            396,
+            825,
+            439
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[42] Shimon Whiteson and Peter Stone. Evolutionary function approximation for reinforcement learning. Journal of Machine Learning Research, 7(May):877–917, 2006. ",
+        "bbox": [
+            181,
+            448,
+            821,
+            477
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[43] George C Williams. Adaptation and natural selection: a critique of some current evolutionary thought, volume 833082108. Princeton science library OCLC, 1966. ",
+        "bbox": [
+            173,
+            486,
+            823,
+            515
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            534,
+            339,
+            547
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes]   \n(c) Did you discuss any potential negative societal impacts of your work? [Yes]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            553,
+            825,
+            640
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            643,
+            493,
+            659
+        ],
+        "page_idx": 11
+    },
+    {
+        "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": [
+            238,
+            662,
+            735,
+            693
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            696,
+            393,
+            710
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [No]   \n(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)? [No]   \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": [
+            238,
+            715,
+            825,
+            830
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            212,
+            834,
+            825,
+            849
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [N/A] (b) Did you mention the license of the assets? [N/A] (c) Did you include any new assets either in the supplemental material or as a URL? [N/A] ",
+        "bbox": [
+            238,
+            853,
+            823,
+            898
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "492 (d) Did you discuss whether and how consent was obtained from people whose data you’re   \n493 using/curating? [N/A]   \n494 (e) Did you discuss whether the data you are using/curating contains personally identifiable   \n495 information or offensive content? [N/A]   \n497 (a) Did you include the full text of instructions given to participants and screenshots, if   \n498 applicable? [N/A]   \n499 (b) Did you describe any potential participant risks, with links to Institutional Review   \n500 Board (IRB) approvals, if applicable? [N/A]   \n501 (c) Did you include the estimated hourly wage paid to participants and the total amount   \n502 spent on participant compensation? [N/A] ",
+        "bbox": [
+            135,
+            88,
+            828,
+            196
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            129,
+            583,
+            828,
+            767
+        ],
+        "page_idx": 12
+    }
+]

parse/train/5la5tka8a4-/5la5tka8a4-.md

@@ -0,0 +1,551 @@
+# Proximal and Federated Random Reshuffling
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+Random Reshuffling (RR), also known as Stochastic Gradient Descent (SGD) without replacement, is a popular and theoretically grounded method for finite-sum minimization. We propose two new algorithms: Proximal and Federated Random Reshuffling (ProxRR and FedRR). The first algorithm, ProxRR, solves composite finite-sum minimization problems in which the objective is the sum of a (potentially non-smooth) convex regularizer and an average of $n$ smooth objectives. ProxRR evaluates the proximal operator once per epoch only. When the proximal operator is expensive to compute, this small difference makes ProxRR up to $n$ times faster than algorithms that evaluate the proximal operator in every iteration, such as proximal (stochastic) gradient descent. We give examples of practical optimization tasks where the proximal operator is difficult to compute and ProxRR has a clear advantage. One such task is federated or distributed optimization, where the evaluation of the proximal operator corresponds to communication across the network. We obtain our second algorithm, FedRR, as a special case of ProxRR applied to federated optimization, and prove it has a smaller communication footprint than either distributed gradient descent or Local SGD. Our theory covers both constant and decreasing stepsizes, and allows for importance resampling schemes that can improve conditioning, which may be of independent interest. Our theory covers both convex and nonconvex regimes. Finally, we corroborate our results with experiments on real data sets.
+
+# 21 1 Introduction
+
+22 Modern theory and practice of training supervised machine learning models is based on the paradigm   
+23 of regularized empirical risk minimization (ERM) [Shalev-Shwartz and Ben-David, 2014]. While the   
+24 ultimate goal of supervised learning is to train models that generalize well to unseen data, in practice   
+25 only a finite data set is available during training. Settling for a model merely minimizing the average   
+26 loss on this training set—the empirical risk—is insufficient, as this often leads to over-fitting and poor   
+27 generalization performance in practice. Due to this reason, empirical risk is virtually always amended   
+28 with a suitably chosen regularizer whose role is to encode prior knowledge about the learning task at   
+29 hand, thus biasing the training algorithm towards better performing models.   
+30 The regularization framework is quite general and perhaps surprisingly it also allows us to consider   
+31 methods for federated learning (FL)—a paradigm in which we aim at training model for a number of   
+32 clients that do not want to reveal their data [Konecný et al. ˇ , 2016, McMahan et al., 2017, Kairouz   
+33 et al., 2019]. The training in FL usually happens on devices with only a small number of model   
+34 updates being shared with a global host. To this end, Federated Averaging algorithm has emerged   
+35 that performs Local SGD updates on the clients’ devices and periodically aggregates their average.   
+36 Its analysis usually requires special techniques and deliberately constructed sequences hindering the   
+37 research in this direction. We shall see, however, that the convergence of our FedRR follows from   
+38 merely applying our algorithm for regularized problems to a carefully chosen reformulation.
+
+39 Formally, regularized ERM problems are optimization problems of the form
+
+$$
+\begin{array} { r } { \underset { x \in \mathbb { R } ^ { d } } { \operatorname* { m i n } } \big [ P ( x ) : = \frac { 1 } { n } \sum _ { i = 1 } ^ { n } f _ { i } ( x ) + \psi ( x ) \big ] , } \end{array}
+$$
+
+where 40 $f _ { i } \colon  { \mathbb { R } ^ { d } } \to  { \mathbb { R } }$ is the loss of model parameterized by vector $x \in \mathbb { R } ^ { d }$ on the $i$ -th training data 41 point, and $\psi : \mathbb { R } ^ { d }  \mathbb { R } \cup \{ + \infty \}$ is a regularizer. Let $[ \acute { n } ] : = \{ 1 , 2 , \ldots , n \}$ . We shall make the 42 following assumption throughout the paper without explicitly mentioning it:
+
+43 Assumption 1. The functions $f _ { i }$ are $L _ { i }$ -smooth, and the regularizer $\psi$ is proper, closed and convex.   
+Let 44 $L _ { \operatorname* { m a x } } : = \operatorname* { m a x } _ { i \in [ n ] } L _ { i }$ .
+
+45 In some results we will additionally assume that either the individual functions $f _ { i }$ , or their average   
+46 $\begin{array} { r } { f : = \frac { 1 } { n } \sum _ { i } f _ { i } } \end{array}$ , or the regularizer $\psi$ are $\mu$ -strongly convex. Whenever we need such additional   
+47 assumptions, we will make this explicitly clear. While all these concepts are standard, we review   
+48 them briefly in Section A.   
+49 Proximal SGD. When the number $n$ of training data points is huge, as is increasingly common   
+50 in practice, the most efficient algorithms for solving (1) are stochastic first-order methods, such   
+51 as stochastic gradient descent (SGD) [Bordes et al., 2009], in one or another of its many variants   
+52 proposed in the last decade [Shang et al., 2018, Pham et al., 2020]. These method almost invariably   
+53 rely on alternating stochastic gradient steps with the evaluation of the proximal operator
+
+$$
+\begin{array} { r } { \operatorname { p r o x } _ { \gamma \psi } ( x ) : = \operatorname * { a r g m i n } _ { z \in \mathbb { R } ^ { d } } \left\{ \gamma \psi ( z ) + \frac { 1 } { 2 } \| z - x \| ^ { 2 } \right\} . } \end{array}
+$$
+
+54 The simplest of these has the form
+
+$$
+\begin{array} { r } { x _ { k + 1 } ^ { \mathrm { S G D } } = \mathrm { p r o x } _ { \gamma _ { k } \psi } ( x _ { k } ^ { \mathrm { S G D } } - \gamma _ { k } \nabla f _ { i _ { k } } ( x _ { k } ^ { \mathrm { S G D } } ) ) , } \end{array}
+$$
+
+55 where $i _ { k }$ is an index from $\{ 1 , 2 , \ldots , n \}$ chosen uniformly at random, and $\gamma _ { k } > 0$ is a properly   
+56 chosen learning rate. Our understanding of (2) is quite mature; see [Gorbunov et al., 2020] for a   
+57 general treatment which considers methods of this form in conjunction with more advanced stochastic   
+58 gradient estimators in place of $\nabla f _ { i _ { k } }$ .   
+59 Applications such as training sparse linear models [Tibshirani, 1996], nonnegative matrix factoriza  
+60 tion [Lee and Seung, 1999], image deblurring [Rudin et al., 1992, Bredies et al., 2010], and training   
+61 with group selection [Yuan and Lin, 2006] all rely on the use of hand-crafted regularizes. For most of   
+62 them, the proximal operator can be evaluated efficiently, and SGD is near or at the top of the list of   
+63 efficient training algorithms.   
+64 Random reshuffling. A particularly successful variant of SGD is based on the idea of random   
+65 shuffling (permutation) of the training data followed by $n$ iterations of the form (2), with the index   
+66 $i _ { k }$ following the pre-selected permutation [Bottou, 2012]. This process is repeated several times,   
+67 each time using a new freshly sampled random permutation of the data, and the resulting method is   
+68 known under the name Random Reshuffling $( R R )$ . When the same permutation is used throughout,   
+69 the technique is known under the name Shuffle-Once $( S O )$ .   
+70 One of the main advantages of this approach is rooted in its intrinsic ability to avoid cache misses when   
+71 reading the data from memory, which enables a significantly faster implementation. Furthermore,   
+72 RR is often observed to converge in fewer iterations than SGD in practice. This can intuitively be   
+73 ascribed to the fact that while due to its sampling-with-replacement approach SGD can miss to learn   
+74 from some data points in any given epoch, RR will learn from each data point in each epoch.   
+75 Understanding the random reshuffling trick, and why it works, has been a non-trivial open problem   
+76 for a long time [Bottou, 2009, Recht and Ré, 2012, Gürbüzbalaban et al., 2019, Haochen and Sra,   
+77 2019]. Until recent development which lead to a significant simplification of the convergence   
+78 analysis technique and proofs [Mishchenko et al., 2020], prior state of the art relied on long and   
+79 elaborate proofs requiring sophisticated arguments and tools, such as analysis via the Wasserstein   
+80 distance [Nagaraj et al., 2019], and relied on a significant number of strong assumptions about   
+81 the objective [Shamir, 2016, Haochen and Sra, 2019]. In alternative recent development, Ahn et al.   
+82 [2020] also develop new tools for analyzing the convergence of random reshuffling, in particular using   
+83 decreasing stepsizes and for objectives satisfying the Polyak-Łojasiewicz condition, a generalization   
+84 of strong convexity [Polyak, 1963, Lojasiewicz, 1963].   
+85 The difficulty of analyzing RR has been the main obstacle in the development of even some of the   
+86 most seemingly benign extensions of the method. Indeed, while all these are well understood in   
+Require: Stepsizes $\gamma _ { t } > 0$ , initial vector $\boldsymbol { x } _ { 0 } \in \mathbb { R } ^ { d }$ , number of epochs $T$   
+1: Sample a permutation $\pi = \left( \pi _ { 0 u } , \pi _ { 1 } , . . . , \pi _ { n - 1 } \right)$ of $[ n ]$ (Do step 1 only for ProxSO)   
+2: for epochs $t = 0 , 1 , \ldots , T - 1$ do   
+3: Sample a permutation $\pi = \left( \pi _ { 0 } , \pi _ { 1 } , \ldots , \pi _ { n - 1 } \right)$ of $[ n ]$ (Do step 3 only for ProxRR)   
+4: $x _ { t } ^ { 0 } = x _ { t }$   
+5: 6: for i = 0, 1, . . . , n − 1 doxi+1t = xit − γt∇fπi (xit)   
+7:   
+87 combination with its much simpler-to-analyze cousin SGD, to the best of our knowledge, there exists   
+88 no theoretical analysis of proximal, parallel, and importance sampling variants of RR with both   
+89 constant and decreasing stepsizes, and in most cases it is not even clear how should such methods be   
+90 constructed. Empowered by and building on the recent advances of Mishchenko et al. [2020], in this   
+91 paper we address all these challenges.
+
+# 92 2 Contributions
+
+In this section we outline the key contributions of our work, and also offer a few intuitive explanations motivating some of the development.
+
+• New algorithm: ProxRR. Despite rich literature on Proximal SGD [Gorbunov et al., 2020], it is not obvious how one should extend RR to solve problem (1) when a regularizer $\psi$ is present. Indeed, the standard practice for SGD is to apply the proximal operator after each stochastic step [Duchi and Singer, 2009], i.e., in analogy with (2). On the other hand, RR is motivated by the fact that a data pass better approximates the full gradient step. If we applied the proximal operator after each step of RR, we would no longer approximate the full gradient after an epoch, as we illustrate next.
+
+Example 1. Let 101 $n = 2$ , $\textstyle \psi ( x ) = { \frac { 1 } { 2 } } \| x \| ^ { 2 }$ , $f _ { 1 } ( x ) = \langle c _ { 1 } , x \rangle$ , $f _ { 2 } ( x ) = \langle c _ { 2 } , x \rangle$ with some $c _ { 1 } , c _ { 2 } \in \mathbb { R } ^ { d }$ , 102 $c _ { 1 } \neq c _ { 2 }$ . Let $\boldsymbol { x } _ { 0 } \in \mathbb { R } ^ { d }$ , $\gamma > 0$ and define $x _ { 1 } = x _ { 0 } - \gamma \nabla f _ { 1 } ( x _ { 0 } )$ , $x _ { 2 } = x _ { 1 } - \gamma \nabla f _ { 2 } ( x _ { 1 } )$ . Then, we 103 have $\mathrm { p r o x } _ { 2 \gamma \psi } ( x _ { 2 } ) = \mathrm { p r o x } _ { 2 \gamma \psi } ( x _ { 0 } - 2 \gamma \nabla f ( x _ { 0 } ) )$ . However, if $\begin{array} { r } { \tilde { x } _ { 1 } = \mathrm { p r o x } _ { \gamma \psi } ( x _ { 0 } - \gamma \nabla f _ { 1 } ( x _ { 0 } ) ) } \end{array}$ and 104 $\begin{array} { r } { \tilde { x } _ { 2 } = \mathrm { p r o x } _ { \gamma \psi } ( x _ { 1 } - \gamma \nabla f _ { 2 } ( \tilde { x } _ { 1 } ) ) } \end{array}$ , then $\tilde { x } _ { 2 } \neq \mathrm { p r o x } _ { 2 \gamma \psi } ( x _ { 0 } - 2 \gamma \nabla f ( x _ { 0 } ) )$ .
+
+105 Motivated by this observation, we propose ProxRR (Algorithm 1), in which the proximal operator is   
+106 applied at the end of each epoch of RR, i.e., after each pass through all randomly reshuffled data. A   
+107 notable property of Algorithm 1 is that only a single proximal operator evaluation is needed during   
+108 each data pass. This is in sharp contrast with the way Proximal SGD works, and offers significant   
+109 advantages in regimes where the evaluation of the proximal mapping is expensive (e.g., comparable   
+110 to the evaluation of $n$ gradients $\nabla f _ { 1 } , \ldots , \nabla f _ { n } )$ .   
+111 • Convergence of ProxRR (for strongly convex functions or regularizer). We establish several   
+112 convergence results for ProxRR, of which we highlight two here. Both offer a linear convergence rate   
+113 with a fixed stepsize to a neighborhood of the solution. In both we reply on Assumption 1. Firstly, in   
+114 the case when in addition, each $f _ { i }$ is $\mu$ -strongly convex, we prove the rate (see Theorem 2)
+
+$$
+\begin{array} { r } { \mathbb { E } \left[ \left. x _ { T } - x _ { * } \right. ^ { 2 } \right] \leq \left( 1 - \gamma \mu \right) ^ { n T } \left. x _ { 0 } - x _ { * } \right. ^ { 2 } + \frac { 2 \gamma ^ { 2 } \sigma _ { \mathrm { r a d } } ^ { 2 } } { \mu } , } \end{array}
+$$
+
+115 where $\gamma _ { t } = \gamma \leq 1 / L _ { \operatorname* { m a x } }$ is the stepsize, and $\sigma _ { \mathrm { r a d } } ^ { 2 }$ is a shuffling radius constant (for precise definition, 116 see (4)). In Theorem 1 we bound the shuffling radius in terms of $\| \nabla f ( x _ { * } ) \| ^ { 2 }$ , n, $L _ { \mathrm { m a x } }$ and the more common quantity 117 $\begin{array} { r } { \sigma _ { * } ^ { 2 } : = \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \| \nabla f _ { i } ( x _ { * } ) - \nabla f ( x _ { * } ) \| ^ { 2 } } \end{array}$ . Secondly, if $\psi$ is $\mu$ -strongly convex, and 118 we choose the stepsize $\gamma _ { t } \overset { \cdot \cdot } { = } \gamma \leq 1 / L _ { \operatorname* { m a x } }$ , we prove the rate (see Theorem 3)
+
+$$
+\begin{array} { r } { \mathbb { E } \left[ \left. x _ { T } - x _ { * } \right. ^ { 2 } \right] \leq \left( 1 + 2 \gamma \mu n \right) ^ { - T } \left. x _ { 0 } - x _ { * } \right. ^ { 2 } + \frac { \gamma ^ { 2 } \sigma _ { \mathrm { r a d } } ^ { 2 } } { \mu } . } \end{array}
+$$
+
+119 Both mentioned rates show exponential (linear in logarithmic scale) convergence to a neighborhood whose size is proportional to 120 $\gamma ^ { 2 } \sigma _ { \mathrm { r a d } } ^ { 2 }$ . Since we can choose $\gamma$ to be arbitrarily small or periodically
+
+121 decrease it, this implies that the iterates converge to $x _ { * }$ in the limit. Moreover, we show in Section 4 that when122 $\begin{array} { r } { \gamma = \mathcal { O } ( \frac { 1 } { T } ) } \end{array}$ the error is $\scriptstyle { \mathcal { O } } ( { \frac { 1 } { T ^ { 2 } } } )$ , which is superior to the $\mathcal { O } ( \textstyle { \frac { 1 } { T } } )$ error of SGD.
+
+• Results for SO. All of our results apply to the Shuffle-Once algorithm as well. For simplicity, we center the discussion around RR, whose current theoretical guarantees in the nonconvex case are better than that of SO. Nevertheless, the other results are the same for both methods, and ProxRR is identical to ProxSO in terms of our theory too. A study of the empirical differences between RR and SO can be found in [Mishchenko et al., 2020].
+
+128 • Application to Federated Learning. In Section 6 we describe an application of our results to   
+129 federated learning [Konecný et al. ˇ , 2016, McMahan et al., 2017, Kairouz et al., 2019]. In this way we   
+130 obtain the FedRR method, which is similar to Local SGD, except the local solver is a single pass   
+131 of RR over the local data. Empirically, FedRR can be vastly superior to Local SGD (see Figure 2).   
+132 Remarkably, we also show that the rate of FedRR beats the best known lower bound for Local SGD   
+133 due to [Woodworth et al., 2020] (we needed to adapt it from the original online to the finite-sum   
+134 setting we consider in this paper) for large enough $n$ . See Section F for more details.
+
+• Nonconvex analysis. In the nonconvex regime, and under suitable assumptions, we establish (see Theorems 5 and 8) an $\begin{array} { r } { \mathcal { O } ( \frac { 1 } { \gamma T } ) } \end{array}$ rate up to a neighborhood of size $\mathcal { O } ( \gamma ^ { 2 } )$ . For a certain stepsize it yields an $\begin{array} { r } { \mathcal { O } ( { \frac { 1 } { \varepsilon ^ { 3 } } } ) } \end{array}$ convergence rate.
+
+Besides the above results, we describe several extensions in the appendix, which we now outline.
+
+• Extension 1: Decreasing stepsizes. The convergence of RR is not always exact and depends on the parameters of the objective. Similarly, if the shuffling radius $\sigma _ { \mathrm { r a d } } ^ { 2 }$ is positive, and we wish to find an $\varepsilon$ -approximate solution, the optimal choice of a fixed stepsize for ProxRR will depend on $\varepsilon$ . This deficiency can be fixed by using decreasing stepsizes in both vanilla RR [Ahn et al., 2020] and in SGD [Stich, 2019]. We adopt the same technique to our setting. However, we depart from [Ahn et al., 2020] by only adjusting the stepsize once per epoch rather than at every iteration, similarly to the concurrent work of Tran et al. [2020] on RR with momentum. For details, see Section I.
+
+146 • Extension 2: Importance resampling for Proximal RR. While importance sampling is a well   
+147 established technique for speeding up the convergence of SGD [Zhao and Zhang, 2015, Khaled and   
+148 Richtárik, 2020], no importance sampling variant of RR has been proposed nor analyzed. This is not   
+149 surprising since the key property of importance sampling in SGD—unbiasedness—does not hold for   
+150 RR. Our approach to equip ProxRR with importance sampling is via a reformulation of problem (1)   
+151 into a similar problem with a larger number of summands. In particular, for each $i \in [ n ]$ we include   
+152 $n _ { i }$ copies of the function $\textstyle { \frac { 1 } { n _ { i } } } f _ { i }$ , and then take average of all $\begin{array} { r } { \bar { N } = \sum _ { i } n _ { i } } \end{array}$ functions constructed this   
+153 way. The value of $n _ { i }$ depends on the “importance” of $f _ { i }$ , described below. We then apply ProxRR   
+154 to this reformulation. If $f _ { i }$ is $L _ { i }$ -smooth for all $i \in [ n ]$ and we let $\begin{array} { r } { \bar { L } : = \frac { 1 } { n } \sum _ { i } L _ { i } } \end{array}$ , then we choose   
+155 . It is easy to show that , and hence our reformulation leads to at most a doubling   
+156 of the number of functions forming the finite sum. However, the overall complexity of ProxRR   
+157 applied to this reformulation will depend on $\bar { L }$ instead of $\operatorname* { m a x } _ { i } L _ { i }$ (see Theorem 10), which can lead   
+158 to a significant improvement. For details of the construction and our complexity results, see Section J.
+
+# 159 3 Preliminaries
+
+160 In our analysis, we build upon the notions of limit points and shuffling variance introduced by 161 Mishchenko et al. [2020] for vanilla (i.e., non-proximal) RR. Given a stepsize $\gamma > 0$ (held constant 162 during each epoch) and a permutation to a neighborhood of intermediate lim $\pi$ of  poi $\{ 1 , 2 , \ldots , n \}$ inner loop iterates of RR/SO convergedefined by $x _ { * } ^ { 1 } , x _ { * } ^ { 2 } , \ldots , x _ { * } ^ { n }$
+
+$$
+\begin{array} { r } { x _ { * } ^ { i } : = x _ { * } - \gamma \sum _ { j = 0 } ^ { i - 1 } \nabla f _ { \pi _ { j } } ( x _ { * } ) , \quad i = 1 , \ldots , n . } \end{array}
+$$
+
+164 The intuition behind this definition is fairly simple: if we performed $i$ steps starting at $x _ { * }$ , we would end up close to 165 $x _ { * } ^ { i }$ . To quantify the closeness, we define the shuffling radius.
+
+166 Definition 1 (Shuffling radius). Given a stepsize $\gamma > 0$ and a random permutation $\pi$ of $\{ 1 , 2 , \ldots , n \}$ used in Algorithm 1, define 167 $x _ { * } ^ { i } = x _ { * } ^ { i } ( \gamma , \pi )$ as in (3). Then, the shuffling radius is defined by
+
+$$
+\begin{array} { r } { \sigma _ { \mathrm { r a d } } ^ { 2 } ( \gamma ) : = \underset { i = 0 , \ldots , n - 1 } { \operatorname* { m a x } } \left[ \frac { 1 } { \gamma ^ { 2 } } \mathbb { E } _ { \boldsymbol \pi } \left[ D _ { f _ { \pi _ { i } } } ( x _ { * } ^ { i } , x _ { * } ) \right] \right] , } \end{array}
+$$
+
+168 where the expectation is taken with respect to the randomness in the permutation $\pi$ . If there are   
+169 multiple steradius, i.e., $\sigma _ { \mathrm { r a d } } ^ { 2 } : = \operatorname* { m a x } _ { t \geq 1 } \sigma _ { \mathrm { r a d } } ^ { 2 } ( \gamma _ { t } )$ $\gamma _ { 1 } , \gamma _ { 2 } , \ldots$ lgorithm 1, we take the maximum of all of them as the shuffling.   
+171 The shuffling radius is related by a multiplicative factor in the stepsize to the shuffling variance   
+172 introduced by Mishchenko et al. [2020]. When the stepsize is held fixed, the difference between the   
+173 two notions is minimal. When the stepsize is decreasing, however, the shuffling radius is easier to   
+174 work with, since it can be upper bounded by problem constants independent of the stepsizes.   
+175 Armed with a special lemma for sampling without replacement, we can upper bound the shuffling   
+176 radius using the smoothness constant $L _ { \mathrm { m a x } }$ , size of the vector $\nabla f ( x _ { * } )$ , and the variance $\sigma _ { * } ^ { 2 }$ of the   
+177 gradient vectors $\nabla f _ { 1 } ( x _ { * } ) , \ldots , \nabla f _ { n } ( x _ { * } )$ .
+
+178 Tof unding twe have $\gamma > 0$ ae any random permutation is a solution of Problem ( $\pi$ $\{ 1 , 2 , \ldots , n \}$ $\begin{array} { r } { \sigma _ { \mathrm { r a d } } ^ { 2 } \leq \frac { L _ { \operatorname* { m a x } } } { 2 } n \big ( n \| \nabla f ( x _ { * } ) \| ^ { 2 } + \frac { 1 } { 2 } \sigma _ { * } ^ { 2 } \big ) } \end{array}$ $x _ { * }$   
+180 and $\sigma _ { * } ^ { 2 }$ is the population variance at the optimum
+
+$$
+\begin{array} { r } { \sigma _ { * } ^ { 2 } : = \frac { 1 } { n } { \sum _ { i = 1 } ^ { n } } \Vert \nabla f _ { i } ( x _ { * } ) - \nabla f ( x _ { * } ) \Vert ^ { 2 } . } \end{array}
+$$
+
+181 All proofs are relegated to the supplementary material. In order to better understand the bound   
+182 given by Theorem 1, note that if there is no proximal operator (i.e., $\psi = 0$ ) then $\nabla f ( x _ { * } ) = 0$ and   
+183 we get that $\begin{array} { r } { \sigma _ { \mathrm { r a d } } ^ { 2 } \le \frac { L _ { \mathrm { m a x } } n \sigma _ { * } ^ { 2 } } { 4 } } \end{array}$ Lmaxnσ2∗4 . This recovers the existing upper bound on the shuffling variance of   
+184 Mishchenko et al. [2020] for vanilla RR. On the other hand, if $\nabla f ( x _ { * } ) \neq 0$ then we get an additive   
+185 term of size proportional to the squared norm of $\nabla f ( x _ { * } )$ .
+
+# 186 4 Theory for strongly convex losses $f _ { 1 } , \ldots , f _ { n }$
+
+187 Our first theorem establishes a convergence rate for Algorithm 1 applied with a constant stepsize to   
+188 Problem (1) when each objective $f _ { i }$ is strongly convex. This assumption is commonly satisfied in   
+189 machine learning applications where each $f _ { i }$ represents a regularized loss on some data points, as in   
+190 $\ell _ { 2 }$ regularized linear regression and $\ell _ { 2 }$ regularized logistic regression.   
+191 Theorem 2. Let Assumption 1 be satisfied. Further, assume that each $f _ { i }$ is $\mu$ -strongly convex. If   
+192 Algorithm 1 is run with constant stepsize $\gamma _ { t } = \gamma \leq 1 / L _ { \operatorname* { m a x } }$ , then its iterates satisfy
+
+$$
+\begin{array} { r } { \mathbb { E } \left[ \left. x _ { T } - x _ { * } \right. ^ { 2 } \right] \leq \left( 1 - \gamma \mu \right) ^ { n T } \left. x _ { 0 } - x _ { * } \right. ^ { 2 } + \frac { 2 \gamma ^ { 2 } \sigma _ { \mathrm { r a d } } ^ { 2 } } { \mu } . } \end{array}
+$$
+
+193 We can convert the guarantee of Theorem 2 to a convergence rate by properly tuning the stepsize   
+194 and using the upper bound of Theorem 1 on the shuffling radius. In particular, if we choose the   
+195 stepsize as $\begin{array} { r } { \gamma = \operatorname* { m i n } \left\{ \frac { 1 } { L _ { \mathrm { m a x } } } , \frac { \sqrt { \varepsilon \mu } } { \sqrt { 2 } \sigma _ { \mathrm { r a d } } } \right\} } \end{array}$ , and let $\kappa : = L _ { \mathrm { m a x } } / \mu$ and $r _ { 0 } : = \| x _ { 0 } - x _ { * } \| ^ { 2 }$ , then we obtain   
+196 $\mathbb { E } \left[ \left. x _ { T } - x _ { * } \right. ^ { 2 } \right] = \dot { \mathcal { O } } \left( \varepsilon \right)$ provided that the total number of iterations $K _ { \mathrm { R R } } = n T$ is at least
+
+$$
+\begin{array} { r } { K _ { \mathrm { R R } } \geq [ ( \kappa + \frac { \sqrt { \kappa n } } { \sqrt { \varepsilon } \mu } ( \sqrt { n } \| \nabla f ( x _ { * } ) \| + \sigma _ { * } ) ] \log \left( \frac { 2 r _ { 0 } } { \varepsilon } \right) . } \end{array}
+$$
+
+197 Comparison with vanilla RR. If there is no proximal operator, then $\| \nabla f ( x _ { * } ) \| = 0$ and we recover   
+198 the earlier result of Mishchenko et al. [2020] on the convergence of RR without proximal, which is   
+199 optimal in $\varepsilon$ up to logarithmic factors. On the other hand, when the proximal operator is nonzero,   
+200 we get an extra term in the complexity proportional to $\| \nabla f ( x _ { * } ) \|$ : thus, even when all the functions   
+201 are the same (i.e., $\sigma _ { * } = 0$ ), we do not recover the linear convergence of Proximal Gradient Descent   
+202 [Karimi et al., 2016, Beck, 2017]. This can be easily explained by the fact that Algorithm 1 performs   
+203 $n$ gradient steps per one proximal step. Hence, even if $f _ { 1 } = \cdots = f _ { n }$ , Algorithm 1 does not reduce   
+204 to Proximal Gradient Descent. We note that other algorithms for composite optimization which may   
+205 not take a proximal step at every iteration (for example, using stochastic projection steps) also suffer   
+206 from the same dependence [Patrascu and Irofti, 2021].   
+207 Comparison with proximal SGD. In order to compare (6) against the complexity of Proximal SGD   
+208 (Algorithm 2), we recall that Proximal SGD achieves $\mathbb { E } \left[ \left. x _ { K } - x _ { * } \right. ^ { 2 } \right] = \mathcal { O } \left( \varepsilon \right)$ if either $f$ or $\psi$ is   
+209 $\mu$ -strongly convex and
+
+$$
+\begin{array} { r } { K _ { \mathrm { S G D } } \geq \left( \kappa + \frac { \sigma _ { \ast } ^ { 2 } } { \varepsilon \mu ^ { 2 } } \right) \log \left( \frac { 2 r _ { 0 } } { \varepsilon } \right) . } \end{array}
+$$
+
+<table><tr><td colspan="2"></td><td>Require: Stepsizes γk &gt; O,initial vector xo ∈ Rd, number of steps K</td><td></td></tr><tr><td colspan="2">1:for steps k=O,1,...,K-1do</td><td></td><td></td></tr><tr><td>2:</td><td>Sample ik uniformly at random from [n]</td><td></td><td></td></tr><tr><td>3:</td><td>Xk+1=prOXγky(xk-γk√fi(xk))</td><td></td><td></td></tr></table>
+
+210 This result is standard [Needell et al., 2016, Gower et al., 2019], with the exception that we do not   
+211 know any proof in the literature for the case when $\psi$ is strongly convex. For completeness, we prove   
+212 it in Appendix C, but since our proof is a minor modification of that in [Gower et al., 2019], we do   
+213 not provide it here.   
+214 By comparing $K _ { \mathrm { S G D } }$ (given by (7)) and $K _ { \mathrm { R R } }$ (given by (6)), we see that ProxRR has milder   
+215 dependence on $\varepsilon$ than Proximal SGD. In particular, ProxRR converges faster whenever the target   
+216 accuracy ε is small enough to satisfy ε ≤ 1Lmaxnµ $\begin{array} { r } { \varepsilon \leq \frac { 1 } { L _ { \operatorname* { m a x } } n \mu } \left( \frac { \sigma _ { * } ^ { 4 } } { n \| \nabla f ( x _ { * } ) \| ^ { 2 } + \sigma _ { * } ^ { 2 } } \right) . } \end{array}$ . Furthermore, ProxRR is much   
+217 better when we consider proximal iteration complexity $\#$ of proximal operator access), in which case   
+218 the complexity of ProxRR (6) is reduced by a factor of $n$ (because we take one proximal step every $n$   
+219 iterations), while the proximal iteration complexity of Proximal SGD remains the same as (7). In this   
+220 case, ProxRR is better whenever the accuracy $\varepsilon$ satisfies
+
+$$
+\begin{array} { r } { \varepsilon \geq \frac { n } { L _ { \operatorname* { m a x } } \mu } \left[ n \| \nabla f ( x _ { * } ) \| ^ { 2 } + \sigma _ { * } ^ { 2 } \right] \qquad \mathrm { o r } \qquad \varepsilon \leq \frac { n } { L _ { \operatorname* { m a x } } \mu } \left[ \frac { \sigma _ { * } ^ { 4 } } { n \| \nabla f ( x _ { * } ) \| ^ { 2 } + \sigma _ { * } ^ { 2 } } \right] . } \end{array}
+$$
+
+21 We can see that if the target accuracy is large enough or small enough, and if the cost of proximal operators dominates the computation, ProxRR is much quicker to converge than Proximal SGD.
+
+# 5 Theory for strongly convex regularizer $\psi$
+
+In Theorem 2, we assume that each $f _ { i }$ is $\mu$ -strongly convex. This is motivated by the common practice of using $\ell _ { 2 }$ regularization in machine learning. However, applying $\ell _ { 2 }$ regularization in every step of Algorithm 1 can be expensive when the data are sparse and the iterates $\ v { x } _ { t } ^ { i }$ are dense, because it requires accessing each coordinate of $\boldsymbol { x } _ { t } ^ { i }$ which can be much more expensive than computing sparse gradients $\nabla f _ { i } ( x _ { t } ^ { i } )$ . Alternatively, we may instead choose to put the $\ell _ { 2 }$ regularization inside $\psi$ and only ask that $\psi$ be strongly convex—this way, we can save a lot of time as we need to access each coordinate of the dense iterates $\boldsymbol { x } _ { t } ^ { i }$ only once per epoch rather than every iteration. Theorem 3 gives a convergence guarantee in this setting.
+
+Theorem 3. Let Assumption 1 hold and $f _ { 1 } , \ldots , f _ { n }$ be convex. Further, assume that $\psi$ is $\mu$ -strongly convex. If Algorithm 1 is run with constant stepsize $\gamma _ { t } = \gamma \leq 1 / L _ { \operatorname* { m a x } }$ , where $L _ { \operatorname* { m a x } } = \operatorname* { m a x } _ { i } L _ { i }$ , then its iterates satisfy
+
+$$
+\begin{array} { r } { \mathbb { E } \left[ \left. x _ { T } - x _ { * } \right. ^ { 2 } \right] \leq ( 1 + 2 \gamma \mu n ) ^ { - T } \left. x _ { 0 } - x _ { * } \right. ^ { 2 } + \frac { \gamma ^ { 2 } \sigma _ { \mathrm { r a d } } ^ { 2 } } { \mu } . } \end{array}
+$$
+
+235 Using Theorem 3 and choosing the stepsize as
+
+$$
+\begin{array} { r } { \gamma = \operatorname* { m i n } \left\{ \frac { 1 } { L _ { \mathrm { m a x } } } , \frac { \sqrt { \varepsilon \mu } } { \sigma _ { \mathrm { r a d } } } \right\} , } \end{array}
+$$
+
+we get 236 $\mathbb { E } \left[ \left. x _ { T } - x _ { * } \right. ^ { 2 } \right] = \mathcal { O } \left( \varepsilon \right)$ provided that the total number of iterations satisfies
+
+$$
+\begin{array} { r } { K \geq \left( \kappa + \frac { \sigma _ { \mathrm { r a d } } / \mu } { \sqrt { \varepsilon \mu } } + n \right) \log \left( \frac { 2 r _ { 0 } } { \varepsilon } \right) . } \end{array}
+$$
+
+237 This can be converted to a bound similar to (6) by using Theorem 1, in which case the only difference   
+238 between the two cases is an extra $n \log \left( { \frac { 1 } { \varepsilon } } \right)$ term when only the regularizer $\psi$ is $\mu$ -strongly convex.   
+239 Since for small enough accuracies the $^ 1 / \sqrt { \varepsilon }$ term dominates, this difference is minimal.
+
+# 240 6 FedRR: application of ProxRR to federated learning
+
+Let us consider now the problem of minimizing the average of 241 $\begin{array} { r } { N = \sum _ { m = 1 } ^ { M } N _ { m } } \end{array}$ PM m=1 Nm functions that are 242 stored on devices, which have $N _ { 1 } , \dots , N _ { M }$ samples correspondingly,
+
+$$
+\begin{array} { r } { \underset { x \in \mathbb { R } ^ { d } } { \operatorname* { m i n } } F ( x ) + R ( x ) , \qquad F ( x ) = \frac { 1 } { N } { \sum _ { m = 1 } ^ { M } } F _ { m } ( x ) , \qquad F _ { m } ( x ) = { \sum _ { j = 1 } ^ { N _ { m } } } f _ { m j } ( x ) . } \end{array}
+$$
+
+# Algorithm 3 Federated Random Reshuffling (FedRR)
+
+<table><tr><td></td><td>Require:Stepsize γ &gt;O,initial vector xo = x ∈ Rd,number of epochs T 1:for epochs t=O,1,...,T-1do</td><td></td><td></td><td></td></tr><tr><td>2:</td><td>for m =1,...,M locally in parallel do</td><td></td><td></td><td></td></tr><tr><td>3:</td><td>xt,m=Xt .0</td><td></td><td></td><td></td></tr><tr><td>4:</td><td>Sample permutation πo,m,π1,m,...,πNm-1,m of {1,2,..., Nm}</td><td></td><td></td><td></td></tr><tr><td>5:</td><td>fori=0,1,...,Nm-1do</td><td></td><td></td><td></td></tr><tr><td>6:</td><td>Ct,m i+1</td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td>7: 8:</td><td></td><td></td><td></td><td></td></tr></table>
+
+243 For example, $f _ { m j } ( x )$ can be the loss associated with a single sample $( X _ { m j } , y _ { m j } )$ , where pairs   
+244 $( X _ { m j } , y _ { m j } )$ follow a distribution $D _ { m }$ that is specific to device $m$ . An important instance of such for  
+245 mulation is federated learning, where $M$ devices train a shared model by communicating periodically   
+246 with a server. We normalize the objective in (10) by $N$ as this is the total number of functions after   
+247 we expand each $F _ { m }$ into a sum. We denote the solution of (10) by $x _ { * }$ .   
+248 Extending the space. To rewrite the problem as an instance of (1), we are going to consider a bigger   
+249 product space, which is sometimes used in distributed optimization [Bianchi et al., 2015]. Let us   
+250 define $n : = \operatorname* { m a x } \{ N _ { 1 } , \dots , N _ { m } \}$ and introduce $\psi _ { C }$ , the consensus constraint, defined via
+
+$$
+\begin{array} { r } { \psi _ { C } ( x _ { 1 } , \dots , x _ { M } ) : = \left\{ \begin{array} { l l } { 0 , } & { x _ { 1 } = \dots = x _ { M } } \\ { + \infty , } & { \mathrm { o t h e r w i s e } } \end{array} \right. . } \end{array}
+$$
+
+251 By introducing dummy variables $x _ { 1 } , \ldots , x _ { M }$ and adding the constraint $x _ { 1 } = \cdot \cdot \cdot = x _ { M }$ , we arrive at   
+252 the intermediate problem
+
+$$
+\operatorname* { m i n } _ { x _ { 1 } , \ldots , x _ { M } \in \mathbb { R } ^ { p } } \frac { 1 } { N } \sum _ { m = 1 } ^ { M } F _ { m } ( x _ { m } ) + ( R + \psi _ { C } ) ( x _ { 1 } , \ldots , x _ { M } ) ,
+$$
+
+53 where $R + \psi _ { C }$ is defined, with a slight abuse of notation, as $( R + \psi _ { C } ) ( x _ { 1 } , \dots , x _ { M } ) = R ( x _ { 1 } )$ if   
+54 $x _ { 1 } = \cdot \cdot \cdot = x _ { M }$ , and $( R + \psi _ { C } ) ( x _ { 1 } , \dots , x _ { M } ) = + \infty$ otherwise.   
+255 Since we have replaced $R$ with a more complicated regularizer $R + \psi _ { C }$ , we need to understand how   
+256 to compute the proximal operator of the latter. We show (Lemma 7 in the supplementary) that the   
+257 proximal operator of $( R + \psi _ { C } )$ is merely the projection onto $\{ ( x _ { 1 } , . . . , x _ { M } ) ^ { \top } | x _ { 1 } = \cdot \cdot \cdot = x _ { M } \}$   
+258 followed by the proximal operator of $R$ with a smaller stepsize.
+
+functions, Reformulation. To have $\textstyle \sum _ { j = N _ { m } + 1 } ^ { n } 0$ $f _ { m j } ( x ) \equiv 0$ . We can now stick the vectors together into for any $n$ functions in every $j > N _ { m }$ , so that $F _ { m }$ $\begin{array} { r } { F _ { m } ( x _ { m } ) = \sum _ { j = 1 } ^ { n } f _ { m j } ( x _ { m } ) = \sum _ { j = 1 } ^ { N _ { m } } f _ { m j } ( x _ { m } ) + } \end{array}$ , we write $\pmb { x } = ( x _ { 1 } , \dots , x _ { M } ) \in \mathbb { R } ^ { M \cdot d }$ $F _ { m }$ as a sum with extra $n - N _ { m }$ 1  and multiply zero the objective by $\textstyle { \frac { N } { n } }$ , which gives the following reformulation:
+
+$$
+\begin{array} { r } { \underset { { \pmb x } \in \mathbb { R } ^ { M \cdot d } } { \operatorname* { m i n } } \frac { 1 } { n } \sum _ { i = 1 } ^ { n } f _ { i } ( { \pmb x } ) + \psi ( { \pmb x } ) , } \end{array}
+$$
+
+where 263 $\begin{array} { r } { \psi ( { \pmb x } ) : = \frac { N } { n } ( R + \psi _ { C } ) } \end{array}$ and
+
+$$
+\begin{array} { l }  \displaystyle { \begin{array} { l } { { \mathrm { ) ~ a n d } } } \\ { { f _ { i } ( x ) = f _ { i } ( x _ { 1 } , \ldots , x _ { M } ) : = \sum ^ { M } f _ { m i } ( x _ { m } ) . } } \end{array} } \end{array}
+$$
+
+264 In other words, function $f _ { i } ( { \pmb x } )$ includes $i$ m=1-th data sample from each device and contains at most   
+265 one loss from every device, while $F _ { m } ( x )$ combines all data losses on device $m$ . Note that the   
+266 solution of (11) is $\pmb { x } _ { * } : = ( x _ { * } ^ { \top } , \ldots , x _ { * } ^ { \top } ) ^ { \top }$ and the gradient of the extended function $f _ { i } ( { \pmb x } )$ is given   
+267 by $\nabla f _ { i } ( { \pmb x } ) = ( \nabla f _ { 1 i } ( x _ { 1 } ) ^ { \top } , \cdots , \nabla f _ { M i } ( x _ { M } ) ^ { \top } ) ^ { \top }$ . Therefore, a stochastic gradient step that uses   
+268 $\nabla f _ { i } ( { \pmb x } )$ corresponds to updating all local models with the gradient of $i$ -th data sample, without any   
+269 communication.   
+270 Algorithm 1 for this specific problem can be written in terms of $x _ { 1 } , \ldots , x _ { M }$ , which results in   
+271 Algorithm 3. Note that since $f _ { m i } ( x _ { i } )$ depends only on $x _ { i }$ , computing its gradient does not require   
+272 communication. Only once the local epochs are finished, the vectors are averaged as the result of   
+273 projecting onto the set $\{ ( x _ { 1 } , \ldots , x _ { M } ) \ | ^  \stackrel { \textstyle - } { x } _ { 1 } = \cdot \cdot \cdot = x _ { M } \}$ .   
+274 Reformulation properties. To analyze FedRR, the only thing that we need to do is understand the   
+275 properties of the reformulation (11) and then apply Theorem 2 or Theorem 3. The following lemma   
+276 gives us the smoothness and strong convexity properties of (11).   
+277 Lemma 1. Let function $f _ { m i }$ be $L _ { i }$ -smooth and $\mu$ -strongly convex for every $m$ . Then, $f _ { i }$ from   
+278 reformulation (11) is $L _ { i }$ -smooth and $\mu$ -strongly convex.   
+279 The previous lemma shows that the conditioning of the reformulation is $\begin{array} { r } { \kappa \ : = \ : \frac { L _ { \mathrm { m a x } } } { \mu } } \end{array}$ just as we   
+280 would expect. Moreover, it implies that the requirement on the stepsize remains exactly the same:   
+281 $\gamma \leq 1 / L _ { \operatorname* { m a x } }$ . What remains unknown is the value of  ProxRR and ProxSO. To find an upper b $\sigma _ { \mathrm { r a d } } ^ { 2 }$ , wh on $\sigma _ { \mathrm { r a d } } ^ { 2 }$ plays a key role in the convergence, let us define
+
+$$
+\begin{array} { r } { \sigma _ { m , * } ^ { 2 } : = \frac { 1 } { N _ { m } } \sum _ { j = 1 } ^ { n } \bigl \| \nabla f _ { m j } ( x _ { * } ) - \frac { 1 } { N _ { m } } \nabla F _ { m } ( x _ { * } ) \bigr \| ^ { 2 } , } \end{array}
+$$
+
+283 which is the variance of local gradients on device $m$ . This quantity characterizes the convergence rate   
+284 of local SGD [Yuan et al., 2020], so we should expect it to appear in our bounds too. The next lemma   
+285 explains how to use it to upper bound $\sigma _ { \mathrm { r a d } } ^ { 2 }$ .
+
+$\sigma _ { \mathrm { r a d } } ^ { 2 }$
+
+$$
+\sigma _ { \mathrm { r a d } } ^ { 2 } \leq L _ { \operatorname* { m a x } } \cdot \sum _ { m = 1 } ^ { M } \Bigl ( \| \nabla F _ { m } ( x _ { * } ) \| ^ { 2 } + \frac { n } { 4 } \sigma _ { m , * } ^ { 2 } \Bigr ) .
+$$
+
+287 The lemma shows that the upper bound on $\sigma _ { \mathrm { r a d } } ^ { 2 }$ depends on the sum of local variances $\textstyle \sum _ { m = 1 } ^ { M } \sigma _ { m , * } ^ { 2 }$ as   
+288 well as on the local gradient norms PMm= $\begin{array} { r } { \sum _ { m = 1 } ^ { M } \| \nabla F _ { m } ( x _ { * } ) \| ^ { 2 } } \end{array}$ . Both of these sums appear in the existing   
+289 literature on convergence of Local GD/SGD [Khaled et al., 2019, Woodworth et al., 2020, Yuan et al.,   
+290 2020]. We are now ready to present formal convergence results. For simplicity, we will consider   
+291 heterogeneous and homogeneous cases separately and assume that $N _ { 1 } = \cdot \cdot \cdot = N _ { M } = n$ . To further   
+292 illustrate generality of our results, we will present the heterogeneous assuming strong convexity $R$   
+293 and the homogeneous under strong convexity of functions $f _ { m i }$ .   
+294 Heterogeneous data. In the case when the data are heterogeneous, we provide the first local RR   
+295 method. We can apply either Theorem 2 or Theorem 3, but for brevity, we give only the corollary   
+296 obtained from Theorem 3.   
+297 Theorem 4. Assume that functions $f _ { m i }$ are convex and $L _ { i }$ -smooth for each $m$ and $i$ . If $R$ is   
+298 $\mu$ -strongly convex and $\gamma \leq 1 / L _ { \operatorname* { m a x } }$ , then we have for the iterates produced by Algorithm 3
+
+$$
+\begin{array} { r } { \mathbb { E } \left[ \left. x _ { T } - x _ { * } \right. ^ { 2 } \right] \leq \left( 1 + 2 \gamma \mu n \right) ^ { - T } \left. x _ { 0 } - x _ { * } \right. ^ { 2 } + \frac { \gamma ^ { 2 } L _ { \operatorname* { m a x } } } { M \mu } \sum _ { m = 1 } ^ { M } \Bigl ( \| \nabla F _ { m } ( x _ { * } ) \| ^ { 2 } + \frac { N } { 4 M } \sigma _ { m , * } ^ { 2 } \Bigr ) . } \end{array}
+$$
+
+299 For nonconvex analysis, we consider $R \equiv 0$ and require the following standard assumption.
+
+300 Assumption 2 (Bounded variance and dissimilarity). There exist constants $\sigma , \zeta > 0$ such that for any 301 $x \in \mathbb { R } ^ { d }$ and
+
+$$
+\begin{array} { r l r l } & { \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \left\| \nabla f _ { m i } - \frac { 1 } { n } \nabla F _ { m } ( \boldsymbol { x } ) \right\| ^ { 2 } \leq \sigma ^ { 2 } } & & { \mathrm { a n d } \quad } & { \frac { 1 } { M } \sum _ { m = 1 } ^ { M } \left\| \frac { 1 } { n } \nabla F _ { m } ( \boldsymbol { x } ) - \nabla F ( \boldsymbol { x } ) \right\| ^ { 2 } \leq \zeta ^ { 2 } . } \end{array}
+$$
+
+Note that above 02 $\begin{array} { r } { \frac { 1 } { n } \nabla F _ { m } ( x ) \ = \ \frac { 1 } { N _ { m } } \nabla F _ { m } ( x ) } \end{array}$ is the gradient of a local dataset and $\nabla F ( x ) \ =$ 303 $\begin{array} { r } { \frac { 1 } { N } \sum _ { l = 1 } ^ { M } \nabla F _ { l } ( x ) } \end{array}$ is the full gradient on all data.
+
+304 Theorem 5 (Nonconvex convergence). Let Assumptions 1 and 2 be satisfied, and $R \equiv 0$ (no prox).
+
+Then, the communication complexity to achieve 305 $\mathbb { E } \left[ \left. \nabla F ( x _ { T } ) \right. ^ { 2 } \right] \leq \varepsilon ^ { 2 }$ is
+
+$$
+\begin{array} { r } { T = { \cal O } \left( \left( \frac { 1 } { \varepsilon ^ { 2 } } + \frac { \sigma } { \sqrt { n } \varepsilon ^ { 3 } } + \frac { \zeta } { \varepsilon ^ { 3 } } \right) \left( F ( x _ { 0 } ) - F _ { * } \right) \right) . } \end{array}
+$$
+
+306 Notice that by replicating the data locally on each device and thereby increasing the value of $n$   
+307 without changing the objective, we can improve the second term in the communication complexity.   
+308 In particular, if the data are not too dissimilar $( \sigma \gg \zeta )$ and $\varepsilon$ is small $\begin{array} { r } { \big ( \frac { 1 } { \varepsilon ^ { 3 } } \gg \frac { 1 } { \varepsilon ^ { 2 } } \big ) } \end{array}$ , the second term in   
+309 the complexity dominates, and it helps to have more local steps. However, if the data are less similar,   
+310 the nodes have to communicate more frequently to get more information about other objectives.   
+311 Homogeneous data. For simplicity, in the homogeneous (i.e., i.i.d.) data case we provide guarantees   
+312 313 $\nabla F _ { m } ( x _ { * } ) = \mathbf { \bar { 0 } }$ oximal op, and thus $\begin{array} { r } { \sigma _ { m , * } ^ { 2 } = \frac { 1 } { n } \sum _ { j = 1 } ^ { n } \| \nabla f _ { m j } ( x _ { * } ) \| ^ { 2 } } \end{array}$ $F _ { 1 } ( x ) = \cdots = F _ { M } ( x )$ , for any hen given $m$ it holds
+
+$$
+\begin{array} { r } { \sum _ { m = 1 } ^ { M } \sigma _ { m , * } ^ { 2 } = \frac { 1 } { n } \sum _ { m = 1 } ^ { M } \sum _ { i = 1 } ^ { n } \| \nabla f _ { m i } ( x _ { * } ) \| ^ { 2 } = \frac { N } { n } \sigma _ { * } ^ { 2 } = M \sigma _ { * } ^ { 2 } , } \end{array}
+$$
+
+where 314 $\begin{array} { r } { \sigma _ { * } ^ { 2 } : = \frac { 1 } { N } \sum _ { i = 1 } ^ { n } \sum _ { m = 1 } ^ { M } \| \nabla f _ { m i } ( x _ { * } ) \| ^ { 2 } } \end{array}$ is the variance of the gradients over all data.
+
+![](images/52d700c2f7bb6beb1bd7db6872296db2aff219ff1e12e4fe8bb14170d8c11387.jpg)  
+Figure 1: Experimental results for problem (12). The first two plots show with average and confidence intervals estimated on 20 random seeds and clearly demonstrate that one can save a lot of proximal operator computations with our method. The right plot shows the best/worst convergence of ProxSO over 20,000 sampled permutations.
+
+![](images/71f29f4a880e40e15cc6e7ee666fa10ec85dcaf9a4be760ccc5a14441873de60.jpg)  
+Figure 2: FedRR vs Local-SGD and Scaffold: i.i.d. data (left) and heterogeneous data (middle and right). We set $\lambda _ { 1 } = 0$ and estimate the averages and standard deviations by running 10 random seeds for each method.
+
+315 Theorem 6. Let $R ( x ) \equiv 0$ (no prox) and the data be i.i.d., that is $\nabla F _ { m } ( x _ { * } ) = 0$ for any $m$ , where   
+316 $x _ { * }$ is the solution of (10). Let $\begin{array} { r } { \sigma _ { * } ^ { 2 } : = \frac { 1 } { N } \sum _ { i = 1 } ^ { n } \sum _ { m = 1 } ^ { M } \| \nabla f _ { m i } ( x _ { * } ) \| ^ { 2 } } \end{array}$ . If each $f _ { m j }$ is $L _ { \mathrm { m a x } }$ -smooth   
+317 and $\mu$ -strongly convex, then the iterates of Algorithm 3 satisfy
+
+$$
+\begin{array} { r } { \mathbb { E } \left[ \| x _ { T } - x _ { * } \| ^ { 2 } \right] \leq ( 1 - \gamma \mu ) ^ { n T } \| x _ { 0 } - x _ { * } \| ^ { 2 } + \frac { \gamma ^ { 2 } L _ { \operatorname* { m a x } } N \sigma _ { * } ^ { 2 } } { M \mu } . } \end{array}
+$$
+
+The most important part of this result is that the last term in Theorem 6 has a factor of $M$ in the denominator, meaning that the convergence bound improves with the number of devices involved.
+
+# 7 Experiments1
+
+ProxRR vs SGD. In Figure 1, we look at the logistic regression loss with the elastic net regularization,
+
+$$
+\begin{array} { r } { \frac { 1 } { N } \sum _ { i = 1 } ^ { N } f _ { i } ( x ) + \lambda _ { 1 } \| x \| _ { 1 } + \frac { \lambda _ { 2 } } { 2 } \| x \| ^ { 2 } , } \end{array}
+$$
+
+where each $f _ { i } : \mathbb { R } ^ { d }  \mathbb { R }$ is defined as f ${ \mathfrak { r } } _ { i } ( x ) : = - { \bigl ( } b _ { i } \log { \bigl ( } h ( a _ { i } ^ { \top } x ) { \bigr ) } + ( 1 - b _ { i } ) \log { \bigl ( } 1 - h ( a _ { i } ^ { \top } x ) { \bigr ) } { \bigr ) }$ , and where $( a _ { i } , b _ { i } ) \in \mathbb { R } ^ { d } \times \{ 0 , 1 \}$ , $i = 1 , \ldots , N$ are the data samples, $h \colon t \to 1 / ( 1 + e ^ { - t } )$ is the sigmoid function, and $\lambda _ { 1 } , \lambda _ { 2 } \geq 0$ are parameters. We set minibatch sizes to 32 for all methods and use theoretical stepsizes, without any tuning. We denote the heuristic version of RR that performs proximal operator step after each iteration as ‘RR (iteration prox)’. From the experiments, we can see that all methods behave more or less the same way. However, the algorithm that we propose needs only a small fraction of proximal operator evaluations, which gives it a huge advantage whenever the operator takes more time to compute than stochastic gradients.
+
+FedRR vs Local SGD and Scaffold. We also compare the performance of FedRR, Local SGD and Scaffold Karimireddy et al. [2020] on homogeneous (i.e., i.i.d.) and heterogeneous data. Since Local SGD and Scaffold require smaller stepsizes to converge, they are significantly slower in the i.i.d. regime, as can be seen in Figure 2. FedRR, however, does not need small initial stepsize and very quickly converges to a noisy neighborhood of the solution. We obtain heterogeneous regime by sorting data with respect to the labels and mixing the sorted dataset with the unsorted one. In this scenario, we also use the same small stepsize for every method to address the data heterogeneity. Clearly, Scaffold is the best in terms of functional values because it does variance reduction with respect to the data. Extending FedRR in the same way might be useful too, but this goes beyond the scope of our paper and we leave it for future work. We also note that in terms of distances from the optimum, FedRR still performs much better than Local SGD and Scaffold.
+
+342 References   
+343 Kwangjun Ahn, Chulhee Yun, and Suvrit Sra. SGD with shuffling: optimal rates without component convexity and large epoch requirements. arXiv preprint arXiv:2006.06946. Neural Information Processing Systems (NeurIPS) 2020, 2020. (Cited on pages 2, 4, and 31)   
+46 Amir Beck. First-Order Methods in Optimization. Society for Industrial and Applied Mathematics, Philadelphia, PA, 2017. doi: 10.1137/1.9781611974997. (Cited on page 5)   
+348 Pascal Bianchi, Walid Hachem, and Franck Iutzeler. A coordinate descent primal-dual algorithm and application to distributed asynchronous optimization. IEEE Transactions on Automatic Control, 61 (10):2947–2957, 2015. (Cited on page 7) Antoine Bordes, Léon Bottou, and Patrick Gallinari. SGD-QN: Careful quasi-Newton stochastic gradient descent. 2009. (Cited on page 2)   
+353 Léon Bottou. Curiously fast convergence of some stochastic gradient descent algorithms. Unpublished open problem offered to the attendance of the SLDS 2009 conference, 2009. URL http://leon. bottou.org/papers/bottou-slds-open-problem-2009. (Cited on page 2)   
+56 Léon Bottou. Stochastic gradient descent tricks. In Neural Networks: Tricks of the Trade, pages 421–436. Springer, 2012. (Cited on page 2)   
+358 Kristian Bredies, Karl Kunisch, and Thomas Pock. Total generalized variation. SIAM Journal on Imaging Sciences, 3(3):492–526, 2010. (Cited on page 2) Gong Chen and Marc Teboulle. Convergence Analysis of a Proximal-Like Minimization Algorithm Using Bregman Functions. SIAM Journal on Optimization, 3(3):538–543, 1993. doi: 10.1137/ 0803026. (Cited on page 19)   
+363 John Duchi and Yoram Singer. Efficient online and batch learning using forward backward splitting. Journal of Machine Learning Research, 10(Dec):2899–2934, 2009. (Cited on page 3) Eduard Gorbunov, Filip Hanzely, and Peter Richtárik. A Unified Theory of SGD: Variance Reduction, Sampling, Quantization and Coordinate Descent. volume 108 of Proceedings of Machine Learning Research, pages 680–690, Online, 26–28 Aug 2020. PMLR. (Cited on pages 2, 3, 18, and 34) Robert M. Gower, Nicolas Loizou, Xun Qian, Alibek Sailanbayev, Egor Shulgin, and Peter Richtárik. SGD: General Analysis and Improved Rates. In Kamalika Chaudhuri and Ruslan Salakhutdinov, editors, Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pages 5200–5209, Long Beach, California, USA, 09–15 Jun 2019. PMLR. (Cited on page 6) Robert M. Gower, Peter Richtárik, and Francis Bach. Stochastic quasi-gradient methods: variance reduction via Jacobian sketching. Mathematical Programming, pages 1–58, 2020. ISSN 0025-5610. doi: 10.1007/s10107-020-01506-0. (Cited on page 34)   
+76 Mert Gürbüzbalaban, Asuman Özdaglar, and Pablo A. Parrilo. Why random reshuffling beats ˘ stochastic gradient descent. Mathematical Programming, Oct 2019. ISSN 1436-4646. doi: 10.1007/s10107-019-01440-w. (Cited on page 2)   
+79 Jeff Haochen and Suvrit Sra. Random Shuffling Beats SGD after Finite Epochs. In Kamalika Chaudhuri and Ruslan Salakhutdinov, editors, Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pages 2624–2633, Long Beach, California, USA, 09–15 Jun 2019. PMLR. (Cited on page 2)   
+383 Peter Kairouz et al. Advances and open problems in federated learning. arXiv preprint arXiv:1912.04977, 2019. (Cited on pages 1 and 4)   
+85 Hamed Karimi, Julie Nutini, and Mark Schmidt. Linear Convergence of Gradient and ProximalGradient Methods Under the Polyak-Łojasiewicz Condition. In European Conference on Machine Learning and Knowledge Discovery in Databases - Volume 9851, ECML PKDD 2016, page 795–811, Berlin, Heidelberg, 2016. Springer-Verlag. (Cited on page 5)
+
+389 Sai Praneeth Karimireddy, Satyen Kale, Mehryar Mohri, Sashank Reddi, Sebastian U. Stich, and   
+390 Ananda Theertha Suresh. SCAFFOLD: Stochastic controlled averaging for federated learning. In   
+391 International Conference on Machine Learning, pages 5132–5143. PMLR, 2020. (Cited on pages 9   
+392 and 30)   
+393 Ahmed Khaled and Peter Richtárik. Better theory for SGD in the nonconvex world. arXiv Preprint   
+394 arXiv:2002.03329, 2020. (Cited on pages 4 and 31)   
+395 Ahmed Khaled, Konstantin Mishchenko, and Peter Richtárik. First Analysis of Local GD on   
+396 Heterogeneous Data. arXiv preprint arXiv:1909.04715, 2019. (Cited on page 8)   
+397 Ahmed Khaled, Konstantin Mishchenko, and Peter Richtárik. Tighter theory for Local SGD on   
+398 identical and heterogeneous data. In International Conference on Artificial Intelligence and   
+399 Statistics, pages 4519–4529. PMLR, 2020. (Cited on page 29)   
+400 Jakub Konecný, H. Brendan McMahan, Felix Yu, Peter Richtárik, Ananda Theertha Suresh, and Dave ˇ   
+401 Bacon. Federated learning: strategies for improving communication efficiency. In NIPS Private   
+402 Multi-Party Machine Learning Workshop, 2016. (Cited on pages 1 and 4)   
+403 Daniel D. Lee and H. Sebastian Seung. Learning the parts of objects by non-negative matrix   
+404 factorization. Nature, 401(6755):788–791, 1999. (Cited on page 2)   
+405 Stanislaw Lojasiewicz. A topological property of real analytic subsets. Coll. du CNRS, Les équations   
+406 aux dérivées partielles, 117:87–89, 1963. (Cited on page 2)   
+407 H. Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Agüera y Arcas.   
+408 Communication-efficient learning of deep networks from decentralized data. In Proceedings of the   
+409 20th International Conference on Artificial Intelligence and Statistics (AISTATS), 2017. (Cited on   
+410 pages 1 and 4)   
+411 Konstantin Mishchenko, Ahmed Khaled, and Peter Richtárik. Random Reshuffling: Simple Analysis   
+412 with Vast Improvements. arXiv preprint arXiv:2006.05988. Neural Information Processing Systems   
+413 (NeurIPS) 2020, 2020. (Cited on pages 2, 3, 4, 5, 16, 19, 20, 25, and 26)   
+414 Dheeraj Nagaraj, Prateek Jain, and Praneeth Netrapalli. SGD without Replacement: Sharper Rates   
+415 for General Smooth Convex Functions. In Kamalika Chaudhuri and Ruslan Salakhutdinov, editors,   
+416 Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings   
+417 of Machine Learning Research, pages 4703–4711, Long Beach, California, USA, 09–15 Jun 2019.   
+418 PMLR. (Cited on page 2)   
+419 Deanna Needell, Nathan Srebro, and Rachel Ward. Stochastic gradient descent, weighted sampling,   
+420 and the randomized Kaczmarz algorithm. Mathematical Programming, 155(1):549–573, Jan 2016.   
+421 ISSN 1436-4646. doi: 10.1007/s10107-015-0864-7. (Cited on pages 6 and 34)   
+422 Neal Parikh and Stephen Boyd. Proximal Algorithms. Foundations and Trends in Optimization, 1(3):   
+423 127–239, January 2014. ISSN 2167-3888. doi: 10.1561/2400000003. (Cited on pages 16 and 30)   
+424 Andrei Patrascu and Paul Irofti. Stochastic proximal splitting algorithm for composite minimization.   
+425 Optimization Letters, pages 1–19, 2021. (Cited on page 5)   
+426 Nhan H. Pham, Lam M. Nguyen, Dzung T. Phan, and Quoc Tran-Dinh. ProxSARAH: An efficient   
+427 algorithmic framework for stochastic composite nonconvex optimization. Journal of Machine   
+428 Learning Research, 21(110):1–48, 2020. (Cited on page 2)   
+429 Boris T. Polyak. Gradient methods for minimizing functionals. Zhurnal Vychislitel’noi Matematiki i   
+430 Matematicheskoi Fiziki, 3(4):643–653, 1963. (Cited on page 2)   
+431 Benjamin Recht and Christopher Ré. Toward a noncommutative arithmetic-geometric mean in  
+432 equality: Conjectures, case-studies, and consequences. In S. Mannor, N. Srebro, and R. C.   
+433 Williamson, editors, Proceedings of the 25th Annual Conference on Learning Theory, volume 23,   
+434 page 11.1–11.24, 2012. Edinburgh, Scotland. (Cited on page 2)   
+435 Leonid I. Rudin, Stanley Osher, and Emad Fatemi. Nonlinear total variation based noise removal   
+436 algorithms. Physica D: nonlinear phenomena, 60(1-4):259–268, 1992. (Cited on page 2)
+
+37 Shai Shalev-Shwartz and Shai Ben-David. Understanding machine learning: from theory to algorithms. Cambridge University Press, 2014. (Cited on page 1) Ohad Shamir. Without-replacement sampling for stochastic gradient methods. In Advances in neural information processing systems, pages 46–54, 2016. (Cited on page 2) Fanhua Shang, Licheng Jiao, Kaiwen Zhou, James Cheng, Yan Ren, and Yufei Jin. ASVRG: Accelerated Proximal SVRG. In Jun Zhu and Ichiro Takeuchi, editors, Proceedings of Machine Learning Research, volume 95, pages 815–830. PMLR, 14–16 Nov 2018. (Cited on page 2) Sebastian U. Stich. Unified Optimal Analysis of the (Stochastic) Gradient Method. arXiv preprint arXiv:1907.04232, 2019. (Cited on pages 4 and 31) Ruo-Yu Sun. Optimization for Deep Learning: An Overview. Journal of the Operations Research Society of China, 8(2):249–294, Jun 2020. ISSN 2194-6698. doi: 10.1007/s40305-020-00309-6. (Cited on page 31) Junqi Tang, Karen Egiazarian, Mohammad Golbabaee, and Mike Davies. The practicality of stochastic optimization in imaging inverse problems. IEEE Transactions on Computational Imaging, 6:1471– 1485, 2020. (Cited on page 34) Robert Tibshirani. Regression shrinkage and selection via the Lasso. Journal of the Royal Statistical Society: Series B (Methodological), 58(1):267–288, 1996. (Cited on page 2) Trang H. Tran, Lam M. Nguyen, and Quoc Tran-Dinh. Shuffling gradient-based methods with momentum. arXiv preprint arXiv:2011.11884, 2020. (Cited on pages 4 and 31) Blake Woodworth, Kumar Kshitij Patel, and Nathan Srebro. Minibatch vs Local SGD for Heterogeneous Distributed Learning. arXiv preprint arXiv:2006.04735. Neural Information Processing Systems (NeurIPS) 2020, 2020. (Cited on pages 4, 8, and 24) Honglin Yuan, Manzil Zaheer, and Sashank Reddi. Federated composite optimization. arXiv preprint arXiv:2011.08474, 2020. (Cited on page 8) Ming Yuan and Yi Lin. Model selection and estimation in regression with grouped variables. Journal of the Royal Statistical Society: Series B (Statistical Methodology), 68(1):49–67, 2006. (Cited on page 2) Peilin Zhao and Tong Zhang. Stochastic optimization with importance sampling for regularized loss minimization. In Proceedings of the 32nd International Conference on Machine Learning, PMLR, volume 37, pages 1–9, 2015. (Cited on page 4)
+
+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? [N/A]   
+(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   
+(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/5la5tka8a4-/5la5tka8a4-_content_list.json

@@ -0,0 +1,1611 @@
+[
+    {
+        "type": "text",
+        "text": "Proximal and Federated Random Reshuffling ",
+        "text_level": 1,
+        "bbox": [
+            220,
+            122,
+            776,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            200,
+            580,
+            256
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            292,
+            535,
+            309
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Random Reshuffling (RR), also known as Stochastic Gradient Descent (SGD) without replacement, is a popular and theoretically grounded method for finite-sum minimization. We propose two new algorithms: Proximal and Federated Random Reshuffling (ProxRR and FedRR). The first algorithm, ProxRR, solves composite finite-sum minimization problems in which the objective is the sum of a (potentially non-smooth) convex regularizer and an average of $n$ smooth objectives. ProxRR evaluates the proximal operator once per epoch only. When the proximal operator is expensive to compute, this small difference makes ProxRR up to $n$ times faster than algorithms that evaluate the proximal operator in every iteration, such as proximal (stochastic) gradient descent. We give examples of practical optimization tasks where the proximal operator is difficult to compute and ProxRR has a clear advantage. One such task is federated or distributed optimization, where the evaluation of the proximal operator corresponds to communication across the network. We obtain our second algorithm, FedRR, as a special case of ProxRR applied to federated optimization, and prove it has a smaller communication footprint than either distributed gradient descent or Local SGD. Our theory covers both constant and decreasing stepsizes, and allows for importance resampling schemes that can improve conditioning, which may be of independent interest. Our theory covers both convex and nonconvex regimes. Finally, we corroborate our results with experiments on real data sets. ",
+        "bbox": [
+            147,
+            324,
+            766,
+            601
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "21 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            147,
+            627,
+            312,
+            643
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "22 Modern theory and practice of training supervised machine learning models is based on the paradigm   \n23 of regularized empirical risk minimization (ERM) [Shalev-Shwartz and Ben-David, 2014]. While the   \n24 ultimate goal of supervised learning is to train models that generalize well to unseen data, in practice   \n25 only a finite data set is available during training. Settling for a model merely minimizing the average   \n26 loss on this training set—the empirical risk—is insufficient, as this often leads to over-fitting and poor   \n27 generalization performance in practice. Due to this reason, empirical risk is virtually always amended   \n28 with a suitably chosen regularizer whose role is to encode prior knowledge about the learning task at   \n29 hand, thus biasing the training algorithm towards better performing models.   \n30 The regularization framework is quite general and perhaps surprisingly it also allows us to consider   \n31 methods for federated learning (FL)—a paradigm in which we aim at training model for a number of   \n32 clients that do not want to reveal their data [Konecný et al. ˇ , 2016, McMahan et al., 2017, Kairouz   \n33 et al., 2019]. The training in FL usually happens on devices with only a small number of model   \n34 updates being shared with a global host. To this end, Federated Averaging algorithm has emerged   \n35 that performs Local SGD updates on the clients’ devices and periodically aggregates their average.   \n36 Its analysis usually requires special techniques and deliberately constructed sequences hindering the   \n37 research in this direction. We shall see, however, that the convergence of our FedRR follows from   \n38 merely applying our algorithm for regularized problems to a carefully chosen reformulation. ",
+        "bbox": [
+            145,
+            659,
+            825,
+            770
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            776,
+            825,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "39 Formally, regularized ERM problems are optimization problems of the form ",
+        "bbox": [
+            143,
+            90,
+            673,
+            106
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b7bc2bdb187e95707c699f2f8bb5b9ab8be7bc0fb8a76581d5215a5e1a4fa0a0.jpg",
+        "text": "$$\n\\begin{array} { r } { \\underset { x \\in \\mathbb { R } ^ { d } } { \\operatorname* { m i n } } \\big [ P ( x ) : = \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } f _ { i } ( x ) + \\psi ( x ) \\big ] , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            109,
+            627,
+            136
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where 40 $f _ { i } \\colon  { \\mathbb { R } ^ { d } } \\to  { \\mathbb { R } }$ is the loss of model parameterized by vector $x \\in \\mathbb { R } ^ { d }$ on the $i$ -th training data 41 point, and $\\psi : \\mathbb { R } ^ { d }  \\mathbb { R } \\cup \\{ + \\infty \\}$ is a regularizer. Let $[ \\acute { n } ] : = \\{ 1 , 2 , \\ldots , n \\}$ . We shall make the 42 following assumption throughout the paper without explicitly mentioning it: ",
+        "bbox": [
+            147,
+            142,
+            825,
+            185
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "43 Assumption 1. The functions $f _ { i }$ are $L _ { i }$ -smooth, and the regularizer $\\psi$ is proper, closed and convex.   \nLet 44 $L _ { \\operatorname* { m a x } } : = \\operatorname* { m a x } _ { i \\in [ n ] } L _ { i }$ . ",
+        "bbox": [
+            150,
+            189,
+            825,
+            219
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "45 In some results we will additionally assume that either the individual functions $f _ { i }$ , or their average   \n46 $\\begin{array} { r } { f : = \\frac { 1 } { n } \\sum _ { i } f _ { i } } \\end{array}$ , or the regularizer $\\psi$ are $\\mu$ -strongly convex. Whenever we need such additional   \n47 assumptions, we will make this explicitly clear. While all these concepts are standard, we review   \n48 them briefly in Section A.   \n49 Proximal SGD. When the number $n$ of training data points is huge, as is increasingly common   \n50 in practice, the most efficient algorithms for solving (1) are stochastic first-order methods, such   \n51 as stochastic gradient descent (SGD) [Bordes et al., 2009], in one or another of its many variants   \n52 proposed in the last decade [Shang et al., 2018, Pham et al., 2020]. These method almost invariably   \n53 rely on alternating stochastic gradient steps with the evaluation of the proximal operator ",
+        "bbox": [
+            147,
+            228,
+            825,
+            285
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            290,
+            825,
+            361
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dec29a355a57ec4964f6fcf181946b2f80306b0d3db2357766e0485fc278edf6.jpg",
+        "text": "$$\n\\begin{array} { r } { \\operatorname { p r o x } _ { \\gamma \\psi } ( x ) : = \\operatorname * { a r g m i n } _ { z \\in \\mathbb { R } ^ { d } } \\left\\{ \\gamma \\psi ( z ) + \\frac { 1 } { 2 } \\| z - x \\| ^ { 2 } \\right\\} . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            364,
+            671,
+            385
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "54 The simplest of these has the form ",
+        "bbox": [
+            147,
+            388,
+            400,
+            404
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b5711073b8aafb60108ed682bf3593620e8537674bf31dd93cfc308fed6bf0ca.jpg",
+        "text": "$$\n\\begin{array} { r } { x _ { k + 1 } ^ { \\mathrm { S G D } } = \\mathrm { p r o x } _ { \\gamma _ { k } \\psi } ( x _ { k } ^ { \\mathrm { S G D } } - \\gamma _ { k } \\nabla f _ { i _ { k } } ( x _ { k } ^ { \\mathrm { S G D } } ) ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            409,
+            643,
+            429
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "55 where $i _ { k }$ is an index from $\\{ 1 , 2 , \\ldots , n \\}$ chosen uniformly at random, and $\\gamma _ { k } > 0$ is a properly   \n56 chosen learning rate. Our understanding of (2) is quite mature; see [Gorbunov et al., 2020] for a   \n57 general treatment which considers methods of this form in conjunction with more advanced stochastic   \n58 gradient estimators in place of $\\nabla f _ { i _ { k } }$ .   \n59 Applications such as training sparse linear models [Tibshirani, 1996], nonnegative matrix factoriza  \n60 tion [Lee and Seung, 1999], image deblurring [Rudin et al., 1992, Bredies et al., 2010], and training   \n61 with group selection [Yuan and Lin, 2006] all rely on the use of hand-crafted regularizes. For most of   \n62 them, the proximal operator can be evaluated efficiently, and SGD is near or at the top of the list of   \n63 efficient training algorithms.   \n64 Random reshuffling. A particularly successful variant of SGD is based on the idea of random   \n65 shuffling (permutation) of the training data followed by $n$ iterations of the form (2), with the index   \n66 $i _ { k }$ following the pre-selected permutation [Bottou, 2012]. This process is repeated several times,   \n67 each time using a new freshly sampled random permutation of the data, and the resulting method is   \n68 known under the name Random Reshuffling $( R R )$ . When the same permutation is used throughout,   \n69 the technique is known under the name Shuffle-Once $( S O )$ .   \n70 One of the main advantages of this approach is rooted in its intrinsic ability to avoid cache misses when   \n71 reading the data from memory, which enables a significantly faster implementation. Furthermore,   \n72 RR is often observed to converge in fewer iterations than SGD in practice. This can intuitively be   \n73 ascribed to the fact that while due to its sampling-with-replacement approach SGD can miss to learn   \n74 from some data points in any given epoch, RR will learn from each data point in each epoch.   \n75 Understanding the random reshuffling trick, and why it works, has been a non-trivial open problem   \n76 for a long time [Bottou, 2009, Recht and Ré, 2012, Gürbüzbalaban et al., 2019, Haochen and Sra,   \n77 2019]. Until recent development which lead to a significant simplification of the convergence   \n78 analysis technique and proofs [Mishchenko et al., 2020], prior state of the art relied on long and   \n79 elaborate proofs requiring sophisticated arguments and tools, such as analysis via the Wasserstein   \n80 distance [Nagaraj et al., 2019], and relied on a significant number of strong assumptions about   \n81 the objective [Shamir, 2016, Haochen and Sra, 2019]. In alternative recent development, Ahn et al.   \n82 [2020] also develop new tools for analyzing the convergence of random reshuffling, in particular using   \n83 decreasing stepsizes and for objectives satisfying the Polyak-Łojasiewicz condition, a generalization   \n84 of strong convexity [Polyak, 1963, Lojasiewicz, 1963].   \n85 The difficulty of analyzing RR has been the main obstacle in the development of even some of the   \n86 most seemingly benign extensions of the method. Indeed, while all these are well understood in   \nRequire: Stepsizes $\\gamma _ { t } > 0$ , initial vector $\\boldsymbol { x } _ { 0 } \\in \\mathbb { R } ^ { d }$ , number of epochs $T$   \n1: Sample a permutation $\\pi = \\left( \\pi _ { 0 u } , \\pi _ { 1 } , . . . , \\pi _ { n - 1 } \\right)$ of $[ n ]$ (Do step 1 only for ProxSO)   \n2: for epochs $t = 0 , 1 , \\ldots , T - 1$ do   \n3: Sample a permutation $\\pi = \\left( \\pi _ { 0 } , \\pi _ { 1 } , \\ldots , \\pi _ { n - 1 } \\right)$ of $[ n ]$ (Do step 3 only for ProxRR)   \n4: $x _ { t } ^ { 0 } = x _ { t }$   \n5: 6: for i = 0, 1, . . . , n − 1 doxi+1t = xit − γt∇fπi (xit)   \n7:   \n87 combination with its much simpler-to-analyze cousin SGD, to the best of our knowledge, there exists   \n88 no theoretical analysis of proximal, parallel, and importance sampling variants of RR with both   \n89 constant and decreasing stepsizes, and in most cases it is not even clear how should such methods be   \n90 constructed. Empowered by and building on the recent advances of Mishchenko et al. [2020], in this   \n91 paper we address all these challenges. ",
+        "bbox": [
+            145,
+            435,
+            825,
+            492
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            497,
+            825,
+            568
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            571,
+            825,
+            656
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            662,
+            825,
+            733
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            738,
+            825,
+            877
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            882,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            116,
+            720,
+            239
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            267,
+            825,
+            338
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "92 2 Contributions ",
+        "text_level": 1,
+        "bbox": [
+            150,
+            358,
+            321,
+            375
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section we outline the key contributions of our work, and also offer a few intuitive explanations motivating some of the development. ",
+        "bbox": [
+            161,
+            388,
+            823,
+            417
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• New algorithm: ProxRR. Despite rich literature on Proximal SGD [Gorbunov et al., 2020], it is not obvious how one should extend RR to solve problem (1) when a regularizer $\\psi$ is present. Indeed, the standard practice for SGD is to apply the proximal operator after each stochastic step [Duchi and Singer, 2009], i.e., in analogy with (2). On the other hand, RR is motivated by the fact that a data pass better approximates the full gradient step. If we applied the proximal operator after each step of RR, we would no longer approximate the full gradient after an epoch, as we illustrate next. ",
+        "bbox": [
+            171,
+            422,
+            825,
+            508
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Example 1. Let 101 $n = 2$ , $\\textstyle \\psi ( x ) = { \\frac { 1 } { 2 } } \\| x \\| ^ { 2 }$ , $f _ { 1 } ( x ) = \\langle c _ { 1 } , x \\rangle$ , $f _ { 2 } ( x ) = \\langle c _ { 2 } , x \\rangle$ with some $c _ { 1 } , c _ { 2 } \\in \\mathbb { R } ^ { d }$ , 102 $c _ { 1 } \\neq c _ { 2 }$ . Let $\\boldsymbol { x } _ { 0 } \\in \\mathbb { R } ^ { d }$ , $\\gamma > 0$ and define $x _ { 1 } = x _ { 0 } - \\gamma \\nabla f _ { 1 } ( x _ { 0 } )$ , $x _ { 2 } = x _ { 1 } - \\gamma \\nabla f _ { 2 } ( x _ { 1 } )$ . Then, we 103 have $\\mathrm { p r o x } _ { 2 \\gamma \\psi } ( x _ { 2 } ) = \\mathrm { p r o x } _ { 2 \\gamma \\psi } ( x _ { 0 } - 2 \\gamma \\nabla f ( x _ { 0 } ) )$ . However, if $\\begin{array} { r } { \\tilde { x } _ { 1 } = \\mathrm { p r o x } _ { \\gamma \\psi } ( x _ { 0 } - \\gamma \\nabla f _ { 1 } ( x _ { 0 } ) ) } \\end{array}$ and 104 $\\begin{array} { r } { \\tilde { x } _ { 2 } = \\mathrm { p r o x } _ { \\gamma \\psi } ( x _ { 1 } - \\gamma \\nabla f _ { 2 } ( \\tilde { x } _ { 1 } ) ) } \\end{array}$ , then $\\tilde { x } _ { 2 } \\neq \\mathrm { p r o x } _ { 2 \\gamma \\psi } ( x _ { 0 } - 2 \\gamma \\nabla f ( x _ { 0 } ) )$ . ",
+        "bbox": [
+            142,
+            511,
+            825,
+            575
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "105 Motivated by this observation, we propose ProxRR (Algorithm 1), in which the proximal operator is   \n106 applied at the end of each epoch of RR, i.e., after each pass through all randomly reshuffled data. A   \n107 notable property of Algorithm 1 is that only a single proximal operator evaluation is needed during   \n108 each data pass. This is in sharp contrast with the way Proximal SGD works, and offers significant   \n109 advantages in regimes where the evaluation of the proximal mapping is expensive (e.g., comparable   \n110 to the evaluation of $n$ gradients $\\nabla f _ { 1 } , \\ldots , \\nabla f _ { n } )$ .   \n111 • Convergence of ProxRR (for strongly convex functions or regularizer). We establish several   \n112 convergence results for ProxRR, of which we highlight two here. Both offer a linear convergence rate   \n113 with a fixed stepsize to a neighborhood of the solution. In both we reply on Assumption 1. Firstly, in   \n114 the case when in addition, each $f _ { i }$ is $\\mu$ -strongly convex, we prove the rate (see Theorem 2) ",
+        "bbox": [
+            140,
+            583,
+            825,
+            669
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            672,
+            825,
+            731
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1f6b185190cf4eacca33efd0613faf41bf96bb8708902c03557deaa4e5577403.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbb { E } \\left[ \\left. x _ { T } - x _ { * } \\right. ^ { 2 } \\right] \\leq \\left( 1 - \\gamma \\mu \\right) ^ { n T } \\left. x _ { 0 } - x _ { * } \\right. ^ { 2 } + \\frac { 2 \\gamma ^ { 2 } \\sigma _ { \\mathrm { r a d } } ^ { 2 } } { \\mu } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            315,
+            736,
+            679,
+            763
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "115 where $\\gamma _ { t } = \\gamma \\leq 1 / L _ { \\operatorname* { m a x } }$ is the stepsize, and $\\sigma _ { \\mathrm { r a d } } ^ { 2 }$ is a shuffling radius constant (for precise definition, 116 see (4)). In Theorem 1 we bound the shuffling radius in terms of $\\| \\nabla f ( x _ { * } ) \\| ^ { 2 }$ , n, $L _ { \\mathrm { m a x } }$ and the more common quantity 117 $\\begin{array} { r } { \\sigma _ { * } ^ { 2 } : = \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } \\| \\nabla f _ { i } ( x _ { * } ) - \\nabla f ( x _ { * } ) \\| ^ { 2 } } \\end{array}$ . Secondly, if $\\psi$ is $\\mu$ -strongly convex, and 118 we choose the stepsize $\\gamma _ { t } \\overset { \\cdot \\cdot } { = } \\gamma \\leq 1 / L _ { \\operatorname* { m a x } }$ , we prove the rate (see Theorem 3) ",
+        "bbox": [
+            142,
+            771,
+            826,
+            835
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b73029afc3436b8e2ce1721a7249258b02b2de7e4d1569cccce5e92564133759.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbb { E } \\left[ \\left. x _ { T } - x _ { * } \\right. ^ { 2 } \\right] \\leq \\left( 1 + 2 \\gamma \\mu n \\right) ^ { - T } \\left. x _ { 0 } - x _ { * } \\right. ^ { 2 } + \\frac { \\gamma ^ { 2 } \\sigma _ { \\mathrm { r a d } } ^ { 2 } } { \\mu } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            842,
+            687,
+            869
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "119 Both mentioned rates show exponential (linear in logarithmic scale) convergence to a neighborhood whose size is proportional to 120 $\\gamma ^ { 2 } \\sigma _ { \\mathrm { r a d } } ^ { 2 }$ . Since we can choose $\\gamma$ to be arbitrarily small or periodically ",
+        "bbox": [
+            140,
+            882,
+            825,
+            912
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "121 decrease it, this implies that the iterates converge to $x _ { * }$ in the limit. Moreover, we show in Section 4 that when122 $\\begin{array} { r } { \\gamma = \\mathcal { O } ( \\frac { 1 } { T } ) } \\end{array}$ the error is $\\scriptstyle { \\mathcal { O } } ( { \\frac { 1 } { T ^ { 2 } } } )$ , which is superior to the $\\mathcal { O } ( \\textstyle { \\frac { 1 } { T } } )$ error of SGD. ",
+        "bbox": [
+            147,
+            90,
+            823,
+            121
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• Results for SO. All of our results apply to the Shuffle-Once algorithm as well. For simplicity, we center the discussion around RR, whose current theoretical guarantees in the nonconvex case are better than that of SO. Nevertheless, the other results are the same for both methods, and ProxRR is identical to ProxSO in terms of our theory too. A study of the empirical differences between RR and SO can be found in [Mishchenko et al., 2020]. ",
+        "bbox": [
+            171,
+            126,
+            825,
+            195
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "128 • Application to Federated Learning. In Section 6 we describe an application of our results to   \n129 federated learning [Konecný et al. ˇ , 2016, McMahan et al., 2017, Kairouz et al., 2019]. In this way we   \n130 obtain the FedRR method, which is similar to Local SGD, except the local solver is a single pass   \n131 of RR over the local data. Empirically, FedRR can be vastly superior to Local SGD (see Figure 2).   \n132 Remarkably, we also show that the rate of FedRR beats the best known lower bound for Local SGD   \n133 due to [Woodworth et al., 2020] (we needed to adapt it from the original online to the finite-sum   \n134 setting we consider in this paper) for large enough $n$ . See Section F for more details. ",
+        "bbox": [
+            147,
+            200,
+            825,
+            299
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• Nonconvex analysis. In the nonconvex regime, and under suitable assumptions, we establish (see Theorems 5 and 8) an $\\begin{array} { r } { \\mathcal { O } ( \\frac { 1 } { \\gamma T } ) } \\end{array}$ rate up to a neighborhood of size $\\mathcal { O } ( \\gamma ^ { 2 } )$ . For a certain stepsize it yields an $\\begin{array} { r } { \\mathcal { O } ( { \\frac { 1 } { \\varepsilon ^ { 3 } } } ) } \\end{array}$ convergence rate. ",
+        "bbox": [
+            173,
+            305,
+            823,
+            352
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Besides the above results, we describe several extensions in the appendix, which we now outline. ",
+        "bbox": [
+            161,
+            357,
+            808,
+            372
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• Extension 1: Decreasing stepsizes. The convergence of RR is not always exact and depends on the parameters of the objective. Similarly, if the shuffling radius $\\sigma _ { \\mathrm { r a d } } ^ { 2 }$ is positive, and we wish to find an $\\varepsilon$ -approximate solution, the optimal choice of a fixed stepsize for ProxRR will depend on $\\varepsilon$ . This deficiency can be fixed by using decreasing stepsizes in both vanilla RR [Ahn et al., 2020] and in SGD [Stich, 2019]. We adopt the same technique to our setting. However, we depart from [Ahn et al., 2020] by only adjusting the stepsize once per epoch rather than at every iteration, similarly to the concurrent work of Tran et al. [2020] on RR with momentum. For details, see Section I. ",
+        "bbox": [
+            171,
+            377,
+            825,
+            474
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "146 • Extension 2: Importance resampling for Proximal RR. While importance sampling is a well   \n147 established technique for speeding up the convergence of SGD [Zhao and Zhang, 2015, Khaled and   \n148 Richtárik, 2020], no importance sampling variant of RR has been proposed nor analyzed. This is not   \n149 surprising since the key property of importance sampling in SGD—unbiasedness—does not hold for   \n150 RR. Our approach to equip ProxRR with importance sampling is via a reformulation of problem (1)   \n151 into a similar problem with a larger number of summands. In particular, for each $i \\in [ n ]$ we include   \n152 $n _ { i }$ copies of the function $\\textstyle { \\frac { 1 } { n _ { i } } } f _ { i }$ , and then take average of all $\\begin{array} { r } { \\bar { N } = \\sum _ { i } n _ { i } } \\end{array}$ functions constructed this   \n153 way. The value of $n _ { i }$ depends on the “importance” of $f _ { i }$ , described below. We then apply ProxRR   \n154 to this reformulation. If $f _ { i }$ is $L _ { i }$ -smooth for all $i \\in [ n ]$ and we let $\\begin{array} { r } { \\bar { L } : = \\frac { 1 } { n } \\sum _ { i } L _ { i } } \\end{array}$ , then we choose   \n155 . It is easy to show that , and hence our reformulation leads to at most a doubling   \n156 of the number of functions forming the finite sum. However, the overall complexity of ProxRR   \n157 applied to this reformulation will depend on $\\bar { L }$ instead of $\\operatorname* { m a x } _ { i } L _ { i }$ (see Theorem 10), which can lead   \n158 to a significant improvement. For details of the construction and our complexity results, see Section J. ",
+        "bbox": [
+            143,
+            481,
+            825,
+            662
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "159 3 Preliminaries ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            685,
+            318,
+            702
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "160 In our analysis, we build upon the notions of limit points and shuffling variance introduced by 161 Mishchenko et al. [2020] for vanilla (i.e., non-proximal) RR. Given a stepsize $\\gamma > 0$ (held constant 162 during each epoch) and a permutation to a neighborhood of intermediate lim $\\pi$ of  poi $\\{ 1 , 2 , \\ldots , n \\}$ inner loop iterates of RR/SO convergedefined by $x _ { * } ^ { 1 } , x _ { * } ^ { 2 } , \\ldots , x _ { * } ^ { n }$ ",
+        "bbox": [
+            140,
+            718,
+            825,
+            775
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/85a2a34d435ed48f856fecc6deac7a444cd310bcc26e3335adc56572907e3319.jpg",
+        "text": "$$\n\\begin{array} { r } { x _ { * } ^ { i } : = x _ { * } - \\gamma \\sum _ { j = 0 } ^ { i - 1 } \\nabla f _ { \\pi _ { j } } ( x _ { * } ) , \\quad i = 1 , \\ldots , n . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            784,
+            656,
+            806
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "164 The intuition behind this definition is fairly simple: if we performed $i$ steps starting at $x _ { * }$ , we would end up close to 165 $x _ { * } ^ { i }$ . To quantify the closeness, we define the shuffling radius. ",
+        "bbox": [
+            148,
+            814,
+            825,
+            843
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "166 Definition 1 (Shuffling radius). Given a stepsize $\\gamma > 0$ and a random permutation $\\pi$ of $\\{ 1 , 2 , \\ldots , n \\}$ used in Algorithm 1, define 167 $x _ { * } ^ { i } = x _ { * } ^ { i } ( \\gamma , \\pi )$ as in (3). Then, the shuffling radius is defined by ",
+        "bbox": [
+            140,
+            848,
+            826,
+            877
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/baef59763d63cdb1bb94a6bafd0dd940065f7d53da8519002a9b14e81a74bd8c.jpg",
+        "text": "$$\n\\begin{array} { r } { \\sigma _ { \\mathrm { r a d } } ^ { 2 } ( \\gamma ) : = \\underset { i = 0 , \\ldots , n - 1 } { \\operatorname* { m a x } } \\left[ \\frac { 1 } { \\gamma ^ { 2 } } \\mathbb { E } _ { \\boldsymbol \\pi } \\left[ D _ { f _ { \\pi _ { i } } } ( x _ { * } ^ { i } , x _ { * } ) \\right] \\right] , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            886,
+            651,
+            914
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "168 where the expectation is taken with respect to the randomness in the permutation $\\pi$ . If there are   \n169 multiple steradius, i.e., $\\sigma _ { \\mathrm { r a d } } ^ { 2 } : = \\operatorname* { m a x } _ { t \\geq 1 } \\sigma _ { \\mathrm { r a d } } ^ { 2 } ( \\gamma _ { t } )$ $\\gamma _ { 1 } , \\gamma _ { 2 } , \\ldots$ lgorithm 1, we take the maximum of all of them as the shuffling.   \n171 The shuffling radius is related by a multiplicative factor in the stepsize to the shuffling variance   \n172 introduced by Mishchenko et al. [2020]. When the stepsize is held fixed, the difference between the   \n173 two notions is minimal. When the stepsize is decreasing, however, the shuffling radius is easier to   \n174 work with, since it can be upper bounded by problem constants independent of the stepsizes.   \n175 Armed with a special lemma for sampling without replacement, we can upper bound the shuffling   \n176 radius using the smoothness constant $L _ { \\mathrm { m a x } }$ , size of the vector $\\nabla f ( x _ { * } )$ , and the variance $\\sigma _ { * } ^ { 2 }$ of the   \n177 gradient vectors $\\nabla f _ { 1 } ( x _ { * } ) , \\ldots , \\nabla f _ { n } ( x _ { * } )$ . ",
+        "bbox": [
+            142,
+            90,
+            825,
+            136
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            142,
+            825,
+            200
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            205,
+            825,
+            248
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "178 Tof unding twe have $\\gamma > 0$ ae any random permutation is a solution of Problem ( $\\pi$ $\\{ 1 , 2 , \\ldots , n \\}$ $\\begin{array} { r } { \\sigma _ { \\mathrm { r a d } } ^ { 2 } \\leq \\frac { L _ { \\operatorname* { m a x } } } { 2 } n \\big ( n \\| \\nabla f ( x _ { * } ) \\| ^ { 2 } + \\frac { 1 } { 2 } \\sigma _ { * } ^ { 2 } \\big ) } \\end{array}$ $x _ { * }$   \n180 and $\\sigma _ { * } ^ { 2 }$ is the population variance at the optimum ",
+        "bbox": [
+            142,
+            251,
+            825,
+            296
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a7a5a22a85dbe4dbb3bd87214b2622b2131c025aa8741ea69be521c10fff893e.jpg",
+        "text": "$$\n\\begin{array} { r } { \\sigma _ { * } ^ { 2 } : = \\frac { 1 } { n } { \\sum _ { i = 1 } ^ { n } } \\Vert \\nabla f _ { i } ( x _ { * } ) - \\nabla f ( x _ { * } ) \\Vert ^ { 2 } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            299,
+            627,
+            320
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "181 All proofs are relegated to the supplementary material. In order to better understand the bound   \n182 given by Theorem 1, note that if there is no proximal operator (i.e., $\\psi = 0$ ) then $\\nabla f ( x _ { * } ) = 0$ and   \n183 we get that $\\begin{array} { r } { \\sigma _ { \\mathrm { r a d } } ^ { 2 } \\le \\frac { L _ { \\mathrm { m a x } } n \\sigma _ { * } ^ { 2 } } { 4 } } \\end{array}$ Lmaxnσ2∗4 . This recovers the existing upper bound on the shuffling variance of   \n184 Mishchenko et al. [2020] for vanilla RR. On the other hand, if $\\nabla f ( x _ { * } ) \\neq 0$ then we get an additive   \n185 term of size proportional to the squared norm of $\\nabla f ( x _ { * } )$ . ",
+        "bbox": [
+            142,
+            329,
+            825,
+            405
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "186 4 Theory for strongly convex losses $f _ { 1 } , \\ldots , f _ { n }$ ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            422,
+            566,
+            440
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "187 Our first theorem establishes a convergence rate for Algorithm 1 applied with a constant stepsize to   \n188 Problem (1) when each objective $f _ { i }$ is strongly convex. This assumption is commonly satisfied in   \n189 machine learning applications where each $f _ { i }$ represents a regularized loss on some data points, as in   \n190 $\\ell _ { 2 }$ regularized linear regression and $\\ell _ { 2 }$ regularized logistic regression.   \n191 Theorem 2. Let Assumption 1 be satisfied. Further, assume that each $f _ { i }$ is $\\mu$ -strongly convex. If   \n192 Algorithm 1 is run with constant stepsize $\\gamma _ { t } = \\gamma \\leq 1 / L _ { \\operatorname* { m a x } }$ , then its iterates satisfy ",
+        "bbox": [
+            142,
+            453,
+            825,
+            510
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            512,
+            825,
+            541
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e9369de54a8c4ef9bd6ccac27b08c98b0539ef37084eeb8bbfcda6a569e7cbb6.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbb { E } \\left[ \\left. x _ { T } - x _ { * } \\right. ^ { 2 } \\right] \\leq \\left( 1 - \\gamma \\mu \\right) ^ { n T } \\left. x _ { 0 } - x _ { * } \\right. ^ { 2 } + \\frac { 2 \\gamma ^ { 2 } \\sigma _ { \\mathrm { r a d } } ^ { 2 } } { \\mu } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            545,
+            681,
+            571
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "193 We can convert the guarantee of Theorem 2 to a convergence rate by properly tuning the stepsize   \n194 and using the upper bound of Theorem 1 on the shuffling radius. In particular, if we choose the   \n195 stepsize as $\\begin{array} { r } { \\gamma = \\operatorname* { m i n } \\left\\{ \\frac { 1 } { L _ { \\mathrm { m a x } } } , \\frac { \\sqrt { \\varepsilon \\mu } } { \\sqrt { 2 } \\sigma _ { \\mathrm { r a d } } } \\right\\} } \\end{array}$ , and let $\\kappa : = L _ { \\mathrm { m a x } } / \\mu$ and $r _ { 0 } : = \\| x _ { 0 } - x _ { * } \\| ^ { 2 }$ , then we obtain   \n196 $\\mathbb { E } \\left[ \\left. x _ { T } - x _ { * } \\right. ^ { 2 } \\right] = \\dot { \\mathcal { O } } \\left( \\varepsilon \\right)$ provided that the total number of iterations $K _ { \\mathrm { R R } } = n T$ is at least ",
+        "bbox": [
+            140,
+            580,
+            826,
+            659
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/30709092e893df99f0e4ca6deb9bb710e88c2a3b2685fabf7b005aa4657872c2.jpg",
+        "text": "$$\n\\begin{array} { r } { K _ { \\mathrm { R R } } \\geq [ ( \\kappa + \\frac { \\sqrt { \\kappa n } } { \\sqrt { \\varepsilon } \\mu } ( \\sqrt { n } \\| \\nabla f ( x _ { * } ) \\| + \\sigma _ { * } ) ] \\log \\left( \\frac { 2 r _ { 0 } } { \\varepsilon } \\right) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            660,
+            674,
+            684
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "197 Comparison with vanilla RR. If there is no proximal operator, then $\\| \\nabla f ( x _ { * } ) \\| = 0$ and we recover   \n198 the earlier result of Mishchenko et al. [2020] on the convergence of RR without proximal, which is   \n199 optimal in $\\varepsilon$ up to logarithmic factors. On the other hand, when the proximal operator is nonzero,   \n200 we get an extra term in the complexity proportional to $\\| \\nabla f ( x _ { * } ) \\|$ : thus, even when all the functions   \n201 are the same (i.e., $\\sigma _ { * } = 0$ ), we do not recover the linear convergence of Proximal Gradient Descent   \n202 [Karimi et al., 2016, Beck, 2017]. This can be easily explained by the fact that Algorithm 1 performs   \n203 $n$ gradient steps per one proximal step. Hence, even if $f _ { 1 } = \\cdots = f _ { n }$ , Algorithm 1 does not reduce   \n204 to Proximal Gradient Descent. We note that other algorithms for composite optimization which may   \n205 not take a proximal step at every iteration (for example, using stochastic projection steps) also suffer   \n206 from the same dependence [Patrascu and Irofti, 2021].   \n207 Comparison with proximal SGD. In order to compare (6) against the complexity of Proximal SGD   \n208 (Algorithm 2), we recall that Proximal SGD achieves $\\mathbb { E } \\left[ \\left. x _ { K } - x _ { * } \\right. ^ { 2 } \\right] = \\mathcal { O } \\left( \\varepsilon \\right)$ if either $f$ or $\\psi$ is   \n209 $\\mu$ -strongly convex and ",
+        "bbox": [
+            140,
+            694,
+            826,
+            835
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            839,
+            825,
+            890
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/752e885114e68d206ff96f00cc5483a2af49fdf0cd9e1c16a26469ecc864e8f3.jpg",
+        "text": "$$\n\\begin{array} { r } { K _ { \\mathrm { S G D } } \\geq \\left( \\kappa + \\frac { \\sigma _ { \\ast } ^ { 2 } } { \\varepsilon \\mu ^ { 2 } } \\right) \\log \\left( \\frac { 2 r _ { 0 } } { \\varepsilon } \\right) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            888,
+            604,
+            916
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/d094bcf455f1b45baa1f8d8d59584dc1bd145487110515dc8d8b3eb3b67d2814.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\"></td><td>Require: Stepsizes γk &gt; O,initial vector xo ∈ Rd, number of steps K</td><td></td></tr><tr><td colspan=\"2\">1:for steps k=O,1,...,K-1do</td><td></td><td></td></tr><tr><td>2:</td><td>Sample ik uniformly at random from [n]</td><td></td><td></td></tr><tr><td>3:</td><td>Xk+1=prOXγky(xk-γk√fi(xk))</td><td></td><td></td></tr></table>",
+        "bbox": [
+            174,
+            109,
+            593,
+            167
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "210 This result is standard [Needell et al., 2016, Gower et al., 2019], with the exception that we do not   \n211 know any proof in the literature for the case when $\\psi$ is strongly convex. For completeness, we prove   \n212 it in Appendix C, but since our proof is a minor modification of that in [Gower et al., 2019], we do   \n213 not provide it here.   \n214 By comparing $K _ { \\mathrm { S G D } }$ (given by (7)) and $K _ { \\mathrm { R R } }$ (given by (6)), we see that ProxRR has milder   \n215 dependence on $\\varepsilon$ than Proximal SGD. In particular, ProxRR converges faster whenever the target   \n216 accuracy ε is small enough to satisfy ε ≤ 1Lmaxnµ $\\begin{array} { r } { \\varepsilon \\leq \\frac { 1 } { L _ { \\operatorname* { m a x } } n \\mu } \\left( \\frac { \\sigma _ { * } ^ { 4 } } { n \\| \\nabla f ( x _ { * } ) \\| ^ { 2 } + \\sigma _ { * } ^ { 2 } } \\right) . } \\end{array}$ . Furthermore, ProxRR is much   \n217 better when we consider proximal iteration complexity $\\#$ of proximal operator access), in which case   \n218 the complexity of ProxRR (6) is reduced by a factor of $n$ (because we take one proximal step every $n$   \n219 iterations), while the proximal iteration complexity of Proximal SGD remains the same as (7). In this   \n220 case, ProxRR is better whenever the accuracy $\\varepsilon$ satisfies ",
+        "bbox": [
+            140,
+            190,
+            825,
+            247
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            138,
+            252,
+            825,
+            359
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8bf6c7f07c5498e4579eefec85ad0c8d572cea1266ee2cbc089e4494cdab7a79.jpg",
+        "text": "$$\n\\begin{array} { r } { \\varepsilon \\geq \\frac { n } { L _ { \\operatorname* { m a x } } \\mu } \\left[ n \\| \\nabla f ( x _ { * } ) \\| ^ { 2 } + \\sigma _ { * } ^ { 2 } \\right] \\qquad \\mathrm { o r } \\qquad \\varepsilon \\leq \\frac { n } { L _ { \\operatorname* { m a x } } \\mu } \\left[ \\frac { \\sigma _ { * } ^ { 4 } } { n \\| \\nabla f ( x _ { * } ) \\| ^ { 2 } + \\sigma _ { * } ^ { 2 } } \\right] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            251,
+            361,
+            743,
+            388
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "21 We can see that if the target accuracy is large enough or small enough, and if the cost of proximal operators dominates the computation, ProxRR is much quicker to converge than Proximal SGD. ",
+        "bbox": [
+            156,
+            390,
+            825,
+            420
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 Theory for strongly convex regularizer $\\psi$ ",
+        "text_level": 1,
+        "bbox": [
+            165,
+            436,
+            545,
+            455
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In Theorem 2, we assume that each $f _ { i }$ is $\\mu$ -strongly convex. This is motivated by the common practice of using $\\ell _ { 2 }$ regularization in machine learning. However, applying $\\ell _ { 2 }$ regularization in every step of Algorithm 1 can be expensive when the data are sparse and the iterates $\\ v { x } _ { t } ^ { i }$ are dense, because it requires accessing each coordinate of $\\boldsymbol { x } _ { t } ^ { i }$ which can be much more expensive than computing sparse gradients $\\nabla f _ { i } ( x _ { t } ^ { i } )$ . Alternatively, we may instead choose to put the $\\ell _ { 2 }$ regularization inside $\\psi$ and only ask that $\\psi$ be strongly convex—this way, we can save a lot of time as we need to access each coordinate of the dense iterates $\\boldsymbol { x } _ { t } ^ { i }$ only once per epoch rather than every iteration. Theorem 3 gives a convergence guarantee in this setting. ",
+        "bbox": [
+            171,
+            467,
+            826,
+            579
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3. Let Assumption 1 hold and $f _ { 1 } , \\ldots , f _ { n }$ be convex. Further, assume that $\\psi$ is $\\mu$ -strongly convex. If Algorithm 1 is run with constant stepsize $\\gamma _ { t } = \\gamma \\leq 1 / L _ { \\operatorname* { m a x } }$ , where $L _ { \\operatorname* { m a x } } = \\operatorname* { m a x } _ { i } L _ { i }$ , then its iterates satisfy ",
+        "bbox": [
+            174,
+            582,
+            825,
+            623
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6bb2634a8c3203bbbfecedf3a81175a34391a77be815ad85d2b73adafab8b53a.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbb { E } \\left[ \\left. x _ { T } - x _ { * } \\right. ^ { 2 } \\right] \\leq ( 1 + 2 \\gamma \\mu n ) ^ { - T } \\left. x _ { 0 } - x _ { * } \\right. ^ { 2 } + \\frac { \\gamma ^ { 2 } \\sigma _ { \\mathrm { r a d } } ^ { 2 } } { \\mu } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            626,
+            687,
+            654
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "235 Using Theorem 3 and choosing the stepsize as ",
+        "bbox": [
+            140,
+            661,
+            480,
+            676
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ec3a711d50d4aaaae0fe0261a4804bde1148397031a02a519809e0587102c623.jpg",
+        "text": "$$\n\\begin{array} { r } { \\gamma = \\operatorname* { m i n } \\left\\{ \\frac { 1 } { L _ { \\mathrm { m a x } } } , \\frac { \\sqrt { \\varepsilon \\mu } } { \\sigma _ { \\mathrm { r a d } } } \\right\\} , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            416,
+            679,
+            578,
+            705
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "we get 236 $\\mathbb { E } \\left[ \\left. x _ { T } - x _ { * } \\right. ^ { 2 } \\right] = \\mathcal { O } \\left( \\varepsilon \\right)$ provided that the total number of iterations satisfies ",
+        "bbox": [
+            143,
+            708,
+            730,
+            733
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4e3409f14b2904e52c2837de453ac175db8c210d4fb981ef1dc3b2d4dfd692ae.jpg",
+        "text": "$$\n\\begin{array} { r } { K \\geq \\left( \\kappa + \\frac { \\sigma _ { \\mathrm { r a d } } / \\mu } { \\sqrt { \\varepsilon \\mu } } + n \\right) \\log \\left( \\frac { 2 r _ { 0 } } { \\varepsilon } \\right) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            736,
+            616,
+            763
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "237 This can be converted to a bound similar to (6) by using Theorem 1, in which case the only difference   \n238 between the two cases is an extra $n \\log \\left( { \\frac { 1 } { \\varepsilon } } \\right)$ term when only the regularizer $\\psi$ is $\\mu$ -strongly convex.   \n239 Since for small enough accuracies the $^ 1 / \\sqrt { \\varepsilon }$ term dominates, this difference is minimal. ",
+        "bbox": [
+            140,
+            765,
+            825,
+            809
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "240 6 FedRR: application of ProxRR to federated learning ",
+        "text_level": 1,
+        "bbox": [
+            147,
+            825,
+            645,
+            844
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Let us consider now the problem of minimizing the average of 241 $\\begin{array} { r } { N = \\sum _ { m = 1 } ^ { M } N _ { m } } \\end{array}$ PM m=1 Nm functions that are 242 stored on devices, which have $N _ { 1 } , \\dots , N _ { M }$ samples correspondingly, ",
+        "bbox": [
+            143,
+            858,
+            823,
+            888
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/21a937255e3c97258b8b4b104ebe14ebe0142d15586352120708f60291db8da3.jpg",
+        "text": "$$\n\\begin{array} { r } { \\underset { x \\in \\mathbb { R } ^ { d } } { \\operatorname* { m i n } } F ( x ) + R ( x ) , \\qquad F ( x ) = \\frac { 1 } { N } { \\sum _ { m = 1 } ^ { M } } F _ { m } ( x ) , \\qquad F _ { m } ( x ) = { \\sum _ { j = 1 } ^ { N _ { m } } } f _ { m j } ( x ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            233,
+            888,
+            763,
+            916
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 3 Federated Random Reshuffling (FedRR) ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            90,
+            531,
+            106
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/e4e96a3fe4790764050d2d148894cf138a0f5b59d4d9e797cc55a841c07dfff6.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Require:Stepsize γ &gt;O,initial vector xo = x ∈ Rd,number of epochs T 1:for epochs t=O,1,...,T-1do</td><td></td><td></td><td></td></tr><tr><td>2:</td><td>for m =1,...,M locally in parallel do</td><td></td><td></td><td></td></tr><tr><td>3:</td><td>xt,m=Xt .0</td><td></td><td></td><td></td></tr><tr><td>4:</td><td>Sample permutation πo,m,π1,m,...,πNm-1,m of {1,2,..., Nm}</td><td></td><td></td><td></td></tr><tr><td>5:</td><td>fori=0,1,...,Nm-1do</td><td></td><td></td><td></td></tr><tr><td>6:</td><td>Ct,m i+1</td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td>7: 8:</td><td></td><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            174,
+            109,
+            640,
+            237
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "243 For example, $f _ { m j } ( x )$ can be the loss associated with a single sample $( X _ { m j } , y _ { m j } )$ , where pairs   \n244 $( X _ { m j } , y _ { m j } )$ follow a distribution $D _ { m }$ that is specific to device $m$ . An important instance of such for  \n245 mulation is federated learning, where $M$ devices train a shared model by communicating periodically   \n246 with a server. We normalize the objective in (10) by $N$ as this is the total number of functions after   \n247 we expand each $F _ { m }$ into a sum. We denote the solution of (10) by $x _ { * }$ .   \n248 Extending the space. To rewrite the problem as an instance of (1), we are going to consider a bigger   \n249 product space, which is sometimes used in distributed optimization [Bianchi et al., 2015]. Let us   \n250 define $n : = \\operatorname* { m a x } \\{ N _ { 1 } , \\dots , N _ { m } \\}$ and introduce $\\psi _ { C }$ , the consensus constraint, defined via ",
+        "bbox": [
+            140,
+            261,
+            826,
+            332
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            337,
+            825,
+            381
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f29f749d898ad73842fd25e94d10dff35ae2e8f9aec846ea806b7b04e5b0081d.jpg",
+        "text": "$$\n\\begin{array} { r } { \\psi _ { C } ( x _ { 1 } , \\dots , x _ { M } ) : = \\left\\{ \\begin{array} { l l } { 0 , } & { x _ { 1 } = \\dots = x _ { M } } \\\\ { + \\infty , } & { \\mathrm { o t h e r w i s e } } \\end{array} \\right. . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            385,
+            656,
+            419
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "251 By introducing dummy variables $x _ { 1 } , \\ldots , x _ { M }$ and adding the constraint $x _ { 1 } = \\cdot \\cdot \\cdot = x _ { M }$ , we arrive at   \n252 the intermediate problem ",
+        "bbox": [
+            135,
+            421,
+            826,
+            450
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3af1c450a6d0895100a25382eccb98a3f1ca6a0ac6aef82cf0733c9222c9f8f8.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { x _ { 1 } , \\ldots , x _ { M } \\in \\mathbb { R } ^ { p } } \\frac { 1 } { N } \\sum _ { m = 1 } ^ { M } F _ { m } ( x _ { m } ) + ( R + \\psi _ { C } ) ( x _ { 1 } , \\ldots , x _ { M } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            453,
+            691,
+            479
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "53 where $R + \\psi _ { C }$ is defined, with a slight abuse of notation, as $( R + \\psi _ { C } ) ( x _ { 1 } , \\dots , x _ { M } ) = R ( x _ { 1 } )$ if   \n54 $x _ { 1 } = \\cdot \\cdot \\cdot = x _ { M }$ , and $( R + \\psi _ { C } ) ( x _ { 1 } , \\dots , x _ { M } ) = + \\infty$ otherwise.   \n255 Since we have replaced $R$ with a more complicated regularizer $R + \\psi _ { C }$ , we need to understand how   \n256 to compute the proximal operator of the latter. We show (Lemma 7 in the supplementary) that the   \n257 proximal operator of $( R + \\psi _ { C } )$ is merely the projection onto $\\{ ( x _ { 1 } , . . . , x _ { M } ) ^ { \\top } | x _ { 1 } = \\cdot \\cdot \\cdot = x _ { M } \\}$   \n258 followed by the proximal operator of $R$ with a smaller stepsize. ",
+        "bbox": [
+            155,
+            483,
+            825,
+            513
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            517,
+            825,
+            574
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "functions, Reformulation. To have $\\textstyle \\sum _ { j = N _ { m } + 1 } ^ { n } 0$ $f _ { m j } ( x ) \\equiv 0$ . We can now stick the vectors together into for any $n$ functions in every $j > N _ { m }$ , so that $F _ { m }$ $\\begin{array} { r } { F _ { m } ( x _ { m } ) = \\sum _ { j = 1 } ^ { n } f _ { m j } ( x _ { m } ) = \\sum _ { j = 1 } ^ { N _ { m } } f _ { m j } ( x _ { m } ) + } \\end{array}$ , we write $\\pmb { x } = ( x _ { 1 } , \\dots , x _ { M } ) \\in \\mathbb { R } ^ { M \\cdot d }$ $F _ { m }$ as a sum with extra $n - N _ { m }$ 1  and multiply zero the objective by $\\textstyle { \\frac { N } { n } }$ , which gives the following reformulation: ",
+        "bbox": [
+            171,
+            579,
+            825,
+            646
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4a31346b6922ef3284d07d8d80160295e253700dff9468da832078d15c4a211c.jpg",
+        "text": "$$\n\\begin{array} { r } { \\underset { { \\pmb x } \\in \\mathbb { R } ^ { M \\cdot d } } { \\operatorname* { m i n } } \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } f _ { i } ( { \\pmb x } ) + \\psi ( { \\pmb x } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            647,
+            599,
+            672
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where 263 $\\begin{array} { r } { \\psi ( { \\pmb x } ) : = \\frac { N } { n } ( R + \\psi _ { C } ) } \\end{array}$ and ",
+        "bbox": [
+            151,
+            675,
+            392,
+            694
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f49561c832a04998cf6de0a625fef4a73d5016d9accb502fa21aec1a4afb894f.jpg",
+        "text": "$$\n\\begin{array} { l }  \\displaystyle { \\begin{array} { l } { { \\mathrm { ) ~ a n d } } } \\\\ { { f _ { i } ( x ) = f _ { i } ( x _ { 1 } , \\ldots , x _ { M } ) : = \\sum ^ { M } f _ { m i } ( x _ { m } ) . } } \\end{array} } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            683,
+            640,
+            715
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "264 In other words, function $f _ { i } ( { \\pmb x } )$ includes $i$ m=1-th data sample from each device and contains at most   \n265 one loss from every device, while $F _ { m } ( x )$ combines all data losses on device $m$ . Note that the   \n266 solution of (11) is $\\pmb { x } _ { * } : = ( x _ { * } ^ { \\top } , \\ldots , x _ { * } ^ { \\top } ) ^ { \\top }$ and the gradient of the extended function $f _ { i } ( { \\pmb x } )$ is given   \n267 by $\\nabla f _ { i } ( { \\pmb x } ) = ( \\nabla f _ { 1 i } ( x _ { 1 } ) ^ { \\top } , \\cdots , \\nabla f _ { M i } ( x _ { M } ) ^ { \\top } ) ^ { \\top }$ . Therefore, a stochastic gradient step that uses   \n268 $\\nabla f _ { i } ( { \\pmb x } )$ corresponds to updating all local models with the gradient of $i$ -th data sample, without any   \n269 communication.   \n270 Algorithm 1 for this specific problem can be written in terms of $x _ { 1 } , \\ldots , x _ { M }$ , which results in   \n271 Algorithm 3. Note that since $f _ { m i } ( x _ { i } )$ depends only on $x _ { i }$ , computing its gradient does not require   \n272 communication. Only once the local epochs are finished, the vectors are averaged as the result of   \n273 projecting onto the set $\\{ ( x _ { 1 } , \\ldots , x _ { M } ) \\ | ^  \\stackrel { \\textstyle - } { x } _ { 1 } = \\cdot \\cdot \\cdot = x _ { M } \\}$ .   \n274 Reformulation properties. To analyze FedRR, the only thing that we need to do is understand the   \n275 properties of the reformulation (11) and then apply Theorem 2 or Theorem 3. The following lemma   \n276 gives us the smoothness and strong convexity properties of (11).   \n277 Lemma 1. Let function $f _ { m i }$ be $L _ { i }$ -smooth and $\\mu$ -strongly convex for every $m$ . Then, $f _ { i }$ from   \n278 reformulation (11) is $L _ { i }$ -smooth and $\\mu$ -strongly convex.   \n279 The previous lemma shows that the conditioning of the reformulation is $\\begin{array} { r } { \\kappa \\ : = \\ : \\frac { L _ { \\mathrm { m a x } } } { \\mu } } \\end{array}$ just as we   \n280 would expect. Moreover, it implies that the requirement on the stepsize remains exactly the same:   \n281 $\\gamma \\leq 1 / L _ { \\operatorname* { m a x } }$ . What remains unknown is the value of  ProxRR and ProxSO. To find an upper b $\\sigma _ { \\mathrm { r a d } } ^ { 2 }$ , wh on $\\sigma _ { \\mathrm { r a d } } ^ { 2 }$ plays a key role in the convergence, let us define ",
+        "bbox": [
+            138,
+            715,
+            825,
+            801
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            806,
+            825,
+            864
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            868,
+            825,
+            912
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            150,
+            90,
+            825,
+            121
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            128,
+            826,
+            190
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c474673b34eee15b3e3fc6f53a50c6eba7a2743fc276db7376911bfe8f3a9280.jpg",
+        "text": "$$\n\\begin{array} { r } { \\sigma _ { m , * } ^ { 2 } : = \\frac { 1 } { N _ { m } } \\sum _ { j = 1 } ^ { n } \\bigl \\| \\nabla f _ { m j } ( x _ { * } ) - \\frac { 1 } { N _ { m } } \\nabla F _ { m } ( x _ { * } ) \\bigr \\| ^ { 2 } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            194,
+            666,
+            217
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "283 which is the variance of local gradients on device $m$ . This quantity characterizes the convergence rate   \n284 of local SGD [Yuan et al., 2020], so we should expect it to appear in our bounds too. The next lemma   \n285 explains how to use it to upper bound $\\sigma _ { \\mathrm { r a d } } ^ { 2 }$ . ",
+        "bbox": [
+            140,
+            224,
+            826,
+            270
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "$\\sigma _ { \\mathrm { r a d } } ^ { 2 }$ ",
+        "bbox": [
+            142,
+            271,
+            722,
+            286
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/76a80f496716335d1b7613264ef245e2849115aa0c3a016af5204790b0e5e483.jpg",
+        "text": "$$\n\\sigma _ { \\mathrm { r a d } } ^ { 2 } \\leq L _ { \\operatorname* { m a x } } \\cdot \\sum _ { m = 1 } ^ { M } \\Bigl ( \\| \\nabla F _ { m } ( x _ { * } ) \\| ^ { 2 } + \\frac { n } { 4 } \\sigma _ { m , * } ^ { 2 } \\Bigr ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            284,
+            651,
+            324
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "287 The lemma shows that the upper bound on $\\sigma _ { \\mathrm { r a d } } ^ { 2 }$ depends on the sum of local variances $\\textstyle \\sum _ { m = 1 } ^ { M } \\sigma _ { m , * } ^ { 2 }$ as   \n288 well as on the local gradient norms PMm= $\\begin{array} { r } { \\sum _ { m = 1 } ^ { M } \\| \\nabla F _ { m } ( x _ { * } ) \\| ^ { 2 } } \\end{array}$ . Both of these sums appear in the existing   \n289 literature on convergence of Local GD/SGD [Khaled et al., 2019, Woodworth et al., 2020, Yuan et al.,   \n290 2020]. We are now ready to present formal convergence results. For simplicity, we will consider   \n291 heterogeneous and homogeneous cases separately and assume that $N _ { 1 } = \\cdot \\cdot \\cdot = N _ { M } = n$ . To further   \n292 illustrate generality of our results, we will present the heterogeneous assuming strong convexity $R$   \n293 and the homogeneous under strong convexity of functions $f _ { m i }$ .   \n294 Heterogeneous data. In the case when the data are heterogeneous, we provide the first local RR   \n295 method. We can apply either Theorem 2 or Theorem 3, but for brevity, we give only the corollary   \n296 obtained from Theorem 3.   \n297 Theorem 4. Assume that functions $f _ { m i }$ are convex and $L _ { i }$ -smooth for each $m$ and $i$ . If $R$ is   \n298 $\\mu$ -strongly convex and $\\gamma \\leq 1 / L _ { \\operatorname* { m a x } }$ , then we have for the iterates produced by Algorithm 3 ",
+        "bbox": [
+            140,
+            329,
+            826,
+            434
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            438,
+            825,
+            481
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            483,
+            826,
+            512
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dbfcf63341a7d6782107f4695f046f15d02d11f2b8926e26db5989fb9c554232.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbb { E } \\left[ \\left. x _ { T } - x _ { * } \\right. ^ { 2 } \\right] \\leq \\left( 1 + 2 \\gamma \\mu n \\right) ^ { - T } \\left. x _ { 0 } - x _ { * } \\right. ^ { 2 } + \\frac { \\gamma ^ { 2 } L _ { \\operatorname* { m a x } } } { M \\mu } \\sum _ { m = 1 } ^ { M } \\Bigl ( \\| \\nabla F _ { m } ( x _ { * } ) \\| ^ { 2 } + \\frac { N } { 4 M } \\sigma _ { m , * } ^ { 2 } \\Bigr ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            187,
+            515,
+            807,
+            541
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "299 For nonconvex analysis, we consider $R \\equiv 0$ and require the following standard assumption. ",
+        "bbox": [
+            148,
+            550,
+            772,
+            565
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "300 Assumption 2 (Bounded variance and dissimilarity). There exist constants $\\sigma , \\zeta > 0$ such that for any 301 $x \\in \\mathbb { R } ^ { d }$ and ",
+        "bbox": [
+            143,
+            568,
+            825,
+            597
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/be0c17e18371f1cbaa90b31a582b2a59ef9584248f008b8460707678b228609d.jpg",
+        "text": "$$\n\\begin{array} { r l r l } & { \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } \\left\\| \\nabla f _ { m i } - \\frac { 1 } { n } \\nabla F _ { m } ( \\boldsymbol { x } ) \\right\\| ^ { 2 } \\leq \\sigma ^ { 2 } } & & { \\mathrm { a n d } \\quad } & { \\frac { 1 } { M } \\sum _ { m = 1 } ^ { M } \\left\\| \\frac { 1 } { n } \\nabla F _ { m } ( \\boldsymbol { x } ) - \\nabla F ( \\boldsymbol { x } ) \\right\\| ^ { 2 } \\leq \\zeta ^ { 2 } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            191,
+            598,
+            805,
+            622
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Note that above 02 $\\begin{array} { r } { \\frac { 1 } { n } \\nabla F _ { m } ( x ) \\ = \\ \\frac { 1 } { N _ { m } } \\nabla F _ { m } ( x ) } \\end{array}$ is the gradient of a local dataset and $\\nabla F ( x ) \\ =$ 303 $\\begin{array} { r } { \\frac { 1 } { N } \\sum _ { l = 1 } ^ { M } \\nabla F _ { l } ( x ) } \\end{array}$ is the full gradient on all data. ",
+        "bbox": [
+            153,
+            631,
+            823,
+            666
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "304 Theorem 5 (Nonconvex convergence). Let Assumptions 1 and 2 be satisfied, and $R \\equiv 0$ (no prox). ",
+        "bbox": [
+            150,
+            669,
+            825,
+            683
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Then, the communication complexity to achieve 305 $\\mathbb { E } \\left[ \\left. \\nabla F ( x _ { T } ) \\right. ^ { 2 } \\right] \\leq \\varepsilon ^ { 2 }$ is ",
+        "bbox": [
+            145,
+            685,
+            671,
+            708
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5bdc20cc487bd74277b765e554183335b6def7fc36fb18662c126ddfcb5c76f0.jpg",
+        "text": "$$\n\\begin{array} { r } { T = { \\cal O } \\left( \\left( \\frac { 1 } { \\varepsilon ^ { 2 } } + \\frac { \\sigma } { \\sqrt { n } \\varepsilon ^ { 3 } } + \\frac { \\zeta } { \\varepsilon ^ { 3 } } \\right) \\left( F ( x _ { 0 } ) - F _ { * } \\right) \\right) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            710,
+            650,
+            737
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "306 Notice that by replicating the data locally on each device and thereby increasing the value of $n$   \n307 without changing the objective, we can improve the second term in the communication complexity.   \n308 In particular, if the data are not too dissimilar $( \\sigma \\gg \\zeta )$ and $\\varepsilon$ is small $\\begin{array} { r } { \\big ( \\frac { 1 } { \\varepsilon ^ { 3 } } \\gg \\frac { 1 } { \\varepsilon ^ { 2 } } \\big ) } \\end{array}$ , the second term in   \n309 the complexity dominates, and it helps to have more local steps. However, if the data are less similar,   \n310 the nodes have to communicate more frequently to get more information about other objectives.   \n311 Homogeneous data. For simplicity, in the homogeneous (i.e., i.i.d.) data case we provide guarantees   \n312 313 $\\nabla F _ { m } ( x _ { * } ) = \\mathbf { \\bar { 0 } }$ oximal op, and thus $\\begin{array} { r } { \\sigma _ { m , * } ^ { 2 } = \\frac { 1 } { n } \\sum _ { j = 1 } ^ { n } \\| \\nabla f _ { m j } ( x _ { * } ) \\| ^ { 2 } } \\end{array}$ $F _ { 1 } ( x ) = \\cdots = F _ { M } ( x )$ , for any hen given $m$ it holds ",
+        "bbox": [
+            140,
+            744,
+            826,
+            816
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            821,
+            825,
+            867
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/77404991abb0409dd453e7ea404626a0c6c8a9bbfbe728f8d5926867a500c238.jpg",
+        "text": "$$\n\\begin{array} { r } { \\sum _ { m = 1 } ^ { M } \\sigma _ { m , * } ^ { 2 } = \\frac { 1 } { n } \\sum _ { m = 1 } ^ { M } \\sum _ { i = 1 } ^ { n } \\| \\nabla f _ { m i } ( x _ { * } ) \\| ^ { 2 } = \\frac { N } { n } \\sigma _ { * } ^ { 2 } = M \\sigma _ { * } ^ { 2 } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            287,
+            869,
+            707,
+            891
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where 314 $\\begin{array} { r } { \\sigma _ { * } ^ { 2 } : = \\frac { 1 } { N } \\sum _ { i = 1 } ^ { n } \\sum _ { m = 1 } ^ { M } \\| \\nabla f _ { m i } ( x _ { * } ) \\| ^ { 2 } } \\end{array}$ is the variance of the gradients over all data. ",
+        "bbox": [
+            140,
+            895,
+            754,
+            914
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/52d700c2f7bb6beb1bd7db6872296db2aff219ff1e12e4fe8bb14170d8c11387.jpg",
+        "image_caption": [
+            "Figure 1: Experimental results for problem (12). The first two plots show with average and confidence intervals estimated on 20 random seeds and clearly demonstrate that one can save a lot of proximal operator computations with our method. The right plot shows the best/worst convergence of ProxSO over 20,000 sampled permutations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            89,
+            800,
+            190
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/71f29f4a880e40e15cc6e7ee666fa10ec85dcaf9a4be760ccc5a14441873de60.jpg",
+        "image_caption": [
+            "Figure 2: FedRR vs Local-SGD and Scaffold: i.i.d. data (left) and heterogeneous data (middle and right). We set $\\lambda _ { 1 } = 0$ and estimate the averages and standard deviations by running 10 random seeds for each method. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            197,
+            252,
+            794,
+            354
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "315 Theorem 6. Let $R ( x ) \\equiv 0$ (no prox) and the data be i.i.d., that is $\\nabla F _ { m } ( x _ { * } ) = 0$ for any $m$ , where   \n316 $x _ { * }$ is the solution of (10). Let $\\begin{array} { r } { \\sigma _ { * } ^ { 2 } : = \\frac { 1 } { N } \\sum _ { i = 1 } ^ { n } \\sum _ { m = 1 } ^ { M } \\| \\nabla f _ { m i } ( x _ { * } ) \\| ^ { 2 } } \\end{array}$ . If each $f _ { m j }$ is $L _ { \\mathrm { m a x } }$ -smooth   \n317 and $\\mu$ -strongly convex, then the iterates of Algorithm 3 satisfy ",
+        "bbox": [
+            140,
+            414,
+            825,
+            459
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a08e858996aa8b1e576d1a8b3ba96826be98ef49ee1c32b38c396896b16acea6.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbb { E } \\left[ \\| x _ { T } - x _ { * } \\| ^ { 2 } \\right] \\leq ( 1 - \\gamma \\mu ) ^ { n T } \\| x _ { 0 } - x _ { * } \\| ^ { 2 } + \\frac { \\gamma ^ { 2 } L _ { \\operatorname* { m a x } } N \\sigma _ { * } ^ { 2 } } { M \\mu } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            462,
+            692,
+            486
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The most important part of this result is that the last term in Theorem 6 has a factor of $M$ in the denominator, meaning that the convergence bound improves with the number of devices involved. ",
+        "bbox": [
+            169,
+            494,
+            823,
+            525
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 Experiments1 ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            541,
+            316,
+            559
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ProxRR vs SGD. In Figure 1, we look at the logistic regression loss with the elastic net regularization, ",
+        "bbox": [
+            169,
+            573,
+            825,
+            588
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/61e9b44c449c1c2661bd099b3e395e82511ecd85d17e05f10ca1bd35ba13c240.jpg",
+        "text": "$$\n\\begin{array} { r } { \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } f _ { i } ( x ) + \\lambda _ { 1 } \\| x \\| _ { 1 } + \\frac { \\lambda _ { 2 } } { 2 } \\| x \\| ^ { 2 } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            597,
+            617,
+            617
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "where each $f _ { i } : \\mathbb { R } ^ { d }  \\mathbb { R }$ is defined as f ${ \\mathfrak { r } } _ { i } ( x ) : = - { \\bigl ( } b _ { i } \\log { \\bigl ( } h ( a _ { i } ^ { \\top } x ) { \\bigr ) } + ( 1 - b _ { i } ) \\log { \\bigl ( } 1 - h ( a _ { i } ^ { \\top } x ) { \\bigr ) } { \\bigr ) }$ , and where $( a _ { i } , b _ { i } ) \\in \\mathbb { R } ^ { d } \\times \\{ 0 , 1 \\}$ , $i = 1 , \\ldots , N$ are the data samples, $h \\colon t \\to 1 / ( 1 + e ^ { - t } )$ is the sigmoid function, and $\\lambda _ { 1 } , \\lambda _ { 2 } \\geq 0$ are parameters. We set minibatch sizes to 32 for all methods and use theoretical stepsizes, without any tuning. We denote the heuristic version of RR that performs proximal operator step after each iteration as ‘RR (iteration prox)’. From the experiments, we can see that all methods behave more or less the same way. However, the algorithm that we propose needs only a small fraction of proximal operator evaluations, which gives it a huge advantage whenever the operator takes more time to compute than stochastic gradients. ",
+        "bbox": [
+            173,
+            617,
+            825,
+            731
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "FedRR vs Local SGD and Scaffold. We also compare the performance of FedRR, Local SGD and Scaffold Karimireddy et al. [2020] on homogeneous (i.e., i.i.d.) and heterogeneous data. Since Local SGD and Scaffold require smaller stepsizes to converge, they are significantly slower in the i.i.d. regime, as can be seen in Figure 2. FedRR, however, does not need small initial stepsize and very quickly converges to a noisy neighborhood of the solution. We obtain heterogeneous regime by sorting data with respect to the labels and mixing the sorted dataset with the unsorted one. In this scenario, we also use the same small stepsize for every method to address the data heterogeneity. Clearly, Scaffold is the best in terms of functional values because it does variance reduction with respect to the data. Extending FedRR in the same way might be useful too, but this goes beyond the scope of our paper and we leave it for future work. We also note that in terms of distances from the optimum, FedRR still performs much better than Local SGD and Scaffold. ",
+        "bbox": [
+            173,
+            736,
+            825,
+            888
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "342 References   \n343 Kwangjun Ahn, Chulhee Yun, and Suvrit Sra. SGD with shuffling: optimal rates without component convexity and large epoch requirements. arXiv preprint arXiv:2006.06946. Neural Information Processing Systems (NeurIPS) 2020, 2020. (Cited on pages 2, 4, and 31)   \n46 Amir Beck. First-Order Methods in Optimization. Society for Industrial and Applied Mathematics, Philadelphia, PA, 2017. doi: 10.1137/1.9781611974997. (Cited on page 5)   \n348 Pascal Bianchi, Walid Hachem, and Franck Iutzeler. A coordinate descent primal-dual algorithm and application to distributed asynchronous optimization. IEEE Transactions on Automatic Control, 61 (10):2947–2957, 2015. (Cited on page 7) Antoine Bordes, Léon Bottou, and Patrick Gallinari. SGD-QN: Careful quasi-Newton stochastic gradient descent. 2009. (Cited on page 2)   \n353 Léon Bottou. Curiously fast convergence of some stochastic gradient descent algorithms. Unpublished open problem offered to the attendance of the SLDS 2009 conference, 2009. URL http://leon. bottou.org/papers/bottou-slds-open-problem-2009. (Cited on page 2)   \n56 Léon Bottou. Stochastic gradient descent tricks. In Neural Networks: Tricks of the Trade, pages 421–436. Springer, 2012. (Cited on page 2)   \n358 Kristian Bredies, Karl Kunisch, and Thomas Pock. Total generalized variation. SIAM Journal on Imaging Sciences, 3(3):492–526, 2010. (Cited on page 2) Gong Chen and Marc Teboulle. Convergence Analysis of a Proximal-Like Minimization Algorithm Using Bregman Functions. SIAM Journal on Optimization, 3(3):538–543, 1993. doi: 10.1137/ 0803026. (Cited on page 19)   \n363 John Duchi and Yoram Singer. Efficient online and batch learning using forward backward splitting. Journal of Machine Learning Research, 10(Dec):2899–2934, 2009. (Cited on page 3) Eduard Gorbunov, Filip Hanzely, and Peter Richtárik. A Unified Theory of SGD: Variance Reduction, Sampling, Quantization and Coordinate Descent. volume 108 of Proceedings of Machine Learning Research, pages 680–690, Online, 26–28 Aug 2020. PMLR. (Cited on pages 2, 3, 18, and 34) Robert M. Gower, Nicolas Loizou, Xun Qian, Alibek Sailanbayev, Egor Shulgin, and Peter Richtárik. SGD: General Analysis and Improved Rates. In Kamalika Chaudhuri and Ruslan Salakhutdinov, editors, Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pages 5200–5209, Long Beach, California, USA, 09–15 Jun 2019. PMLR. (Cited on page 6) Robert M. Gower, Peter Richtárik, and Francis Bach. Stochastic quasi-gradient methods: variance reduction via Jacobian sketching. Mathematical Programming, pages 1–58, 2020. ISSN 0025-5610. doi: 10.1007/s10107-020-01506-0. (Cited on page 34)   \n76 Mert Gürbüzbalaban, Asuman Özdaglar, and Pablo A. Parrilo. Why random reshuffling beats ˘ stochastic gradient descent. Mathematical Programming, Oct 2019. ISSN 1436-4646. doi: 10.1007/s10107-019-01440-w. (Cited on page 2)   \n79 Jeff Haochen and Suvrit Sra. Random Shuffling Beats SGD after Finite Epochs. In Kamalika Chaudhuri and Ruslan Salakhutdinov, editors, Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pages 2624–2633, Long Beach, California, USA, 09–15 Jun 2019. PMLR. (Cited on page 2)   \n383 Peter Kairouz et al. Advances and open problems in federated learning. arXiv preprint arXiv:1912.04977, 2019. (Cited on pages 1 and 4)   \n85 Hamed Karimi, Julie Nutini, and Mark Schmidt. Linear Convergence of Gradient and ProximalGradient Methods Under the Polyak-Łojasiewicz Condition. In European Conference on Machine Learning and Knowledge Discovery in Databases - Volume 9851, ECML PKDD 2016, page 795–811, Berlin, Heidelberg, 2016. Springer-Verlag. (Cited on page 5) ",
+        "bbox": [
+            151,
+            82,
+            828,
+            917
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "389 Sai Praneeth Karimireddy, Satyen Kale, Mehryar Mohri, Sashank Reddi, Sebastian U. Stich, and   \n390 Ananda Theertha Suresh. SCAFFOLD: Stochastic controlled averaging for federated learning. In   \n391 International Conference on Machine Learning, pages 5132–5143. PMLR, 2020. (Cited on pages 9   \n392 and 30)   \n393 Ahmed Khaled and Peter Richtárik. Better theory for SGD in the nonconvex world. arXiv Preprint   \n394 arXiv:2002.03329, 2020. (Cited on pages 4 and 31)   \n395 Ahmed Khaled, Konstantin Mishchenko, and Peter Richtárik. First Analysis of Local GD on   \n396 Heterogeneous Data. arXiv preprint arXiv:1909.04715, 2019. (Cited on page 8)   \n397 Ahmed Khaled, Konstantin Mishchenko, and Peter Richtárik. Tighter theory for Local SGD on   \n398 identical and heterogeneous data. In International Conference on Artificial Intelligence and   \n399 Statistics, pages 4519–4529. PMLR, 2020. (Cited on page 29)   \n400 Jakub Konecný, H. Brendan McMahan, Felix Yu, Peter Richtárik, Ananda Theertha Suresh, and Dave ˇ   \n401 Bacon. Federated learning: strategies for improving communication efficiency. In NIPS Private   \n402 Multi-Party Machine Learning Workshop, 2016. (Cited on pages 1 and 4)   \n403 Daniel D. Lee and H. Sebastian Seung. Learning the parts of objects by non-negative matrix   \n404 factorization. Nature, 401(6755):788–791, 1999. (Cited on page 2)   \n405 Stanislaw Lojasiewicz. A topological property of real analytic subsets. Coll. du CNRS, Les équations   \n406 aux dérivées partielles, 117:87–89, 1963. (Cited on page 2)   \n407 H. Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Agüera y Arcas.   \n408 Communication-efficient learning of deep networks from decentralized data. In Proceedings of the   \n409 20th International Conference on Artificial Intelligence and Statistics (AISTATS), 2017. (Cited on   \n410 pages 1 and 4)   \n411 Konstantin Mishchenko, Ahmed Khaled, and Peter Richtárik. Random Reshuffling: Simple Analysis   \n412 with Vast Improvements. arXiv preprint arXiv:2006.05988. Neural Information Processing Systems   \n413 (NeurIPS) 2020, 2020. (Cited on pages 2, 3, 4, 5, 16, 19, 20, 25, and 26)   \n414 Dheeraj Nagaraj, Prateek Jain, and Praneeth Netrapalli. SGD without Replacement: Sharper Rates   \n415 for General Smooth Convex Functions. In Kamalika Chaudhuri and Ruslan Salakhutdinov, editors,   \n416 Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings   \n417 of Machine Learning Research, pages 4703–4711, Long Beach, California, USA, 09–15 Jun 2019.   \n418 PMLR. (Cited on page 2)   \n419 Deanna Needell, Nathan Srebro, and Rachel Ward. Stochastic gradient descent, weighted sampling,   \n420 and the randomized Kaczmarz algorithm. Mathematical Programming, 155(1):549–573, Jan 2016.   \n421 ISSN 1436-4646. doi: 10.1007/s10107-015-0864-7. (Cited on pages 6 and 34)   \n422 Neal Parikh and Stephen Boyd. Proximal Algorithms. Foundations and Trends in Optimization, 1(3):   \n423 127–239, January 2014. ISSN 2167-3888. doi: 10.1561/2400000003. (Cited on pages 16 and 30)   \n424 Andrei Patrascu and Paul Irofti. Stochastic proximal splitting algorithm for composite minimization.   \n425 Optimization Letters, pages 1–19, 2021. (Cited on page 5)   \n426 Nhan H. Pham, Lam M. Nguyen, Dzung T. Phan, and Quoc Tran-Dinh. ProxSARAH: An efficient   \n427 algorithmic framework for stochastic composite nonconvex optimization. Journal of Machine   \n428 Learning Research, 21(110):1–48, 2020. (Cited on page 2)   \n429 Boris T. Polyak. Gradient methods for minimizing functionals. Zhurnal Vychislitel’noi Matematiki i   \n430 Matematicheskoi Fiziki, 3(4):643–653, 1963. (Cited on page 2)   \n431 Benjamin Recht and Christopher Ré. Toward a noncommutative arithmetic-geometric mean in  \n432 equality: Conjectures, case-studies, and consequences. In S. Mannor, N. Srebro, and R. C.   \n433 Williamson, editors, Proceedings of the 25th Annual Conference on Learning Theory, volume 23,   \n434 page 11.1–11.24, 2012. Edinburgh, Scotland. (Cited on page 2)   \n435 Leonid I. Rudin, Stanley Osher, and Emad Fatemi. Nonlinear total variation based noise removal   \n436 algorithms. Physica D: nonlinear phenomena, 60(1-4):259–268, 1992. (Cited on page 2) ",
+        "bbox": [
+            127,
+            82,
+            828,
+            919
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "37 Shai Shalev-Shwartz and Shai Ben-David. Understanding machine learning: from theory to algorithms. Cambridge University Press, 2014. (Cited on page 1) Ohad Shamir. Without-replacement sampling for stochastic gradient methods. In Advances in neural information processing systems, pages 46–54, 2016. (Cited on page 2) Fanhua Shang, Licheng Jiao, Kaiwen Zhou, James Cheng, Yan Ren, and Yufei Jin. ASVRG: Accelerated Proximal SVRG. In Jun Zhu and Ichiro Takeuchi, editors, Proceedings of Machine Learning Research, volume 95, pages 815–830. PMLR, 14–16 Nov 2018. (Cited on page 2) Sebastian U. Stich. Unified Optimal Analysis of the (Stochastic) Gradient Method. arXiv preprint arXiv:1907.04232, 2019. (Cited on pages 4 and 31) Ruo-Yu Sun. Optimization for Deep Learning: An Overview. Journal of the Operations Research Society of China, 8(2):249–294, Jun 2020. ISSN 2194-6698. doi: 10.1007/s40305-020-00309-6. (Cited on page 31) Junqi Tang, Karen Egiazarian, Mohammad Golbabaee, and Mike Davies. The practicality of stochastic optimization in imaging inverse problems. IEEE Transactions on Computational Imaging, 6:1471– 1485, 2020. (Cited on page 34) Robert Tibshirani. Regression shrinkage and selection via the Lasso. Journal of the Royal Statistical Society: Series B (Methodological), 58(1):267–288, 1996. (Cited on page 2) Trang H. Tran, Lam M. Nguyen, and Quoc Tran-Dinh. Shuffling gradient-based methods with momentum. arXiv preprint arXiv:2011.11884, 2020. (Cited on pages 4 and 31) Blake Woodworth, Kumar Kshitij Patel, and Nathan Srebro. Minibatch vs Local SGD for Heterogeneous Distributed Learning. arXiv preprint arXiv:2006.04735. Neural Information Processing Systems (NeurIPS) 2020, 2020. (Cited on pages 4, 8, and 24) Honglin Yuan, Manzil Zaheer, and Sashank Reddi. Federated composite optimization. arXiv preprint arXiv:2011.08474, 2020. (Cited on page 8) Ming Yuan and Yi Lin. Model selection and estimation in regression with grouped variables. Journal of the Royal Statistical Society: Series B (Statistical Methodology), 68(1):49–67, 2006. (Cited on page 2) Peilin Zhao and Tong Zhang. Stochastic optimization with importance sampling for regularized loss minimization. In Proceedings of the 32nd International Conference on Machine Learning, PMLR, volume 37, pages 1–9, 2015. (Cited on page 4) ",
+        "bbox": [
+            156,
+            84,
+            828,
+            619
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            131
+        ],
+        "page_idx": 12
+    },
+    {
+        "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,
+            135,
+            825,
+            227
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            231,
+            493,
+            244
+        ],
+        "page_idx": 12
+    },
+    {
+        "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,
+            248,
+            735,
+            280
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            212,
+            285,
+            393,
+            299
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes]   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   \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": [
+            238,
+            303,
+            826,
+            421
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            215,
+            426,
+            823,
+            440
+        ],
+        "page_idx": 12
+    },
+    {
+        "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? [N/A]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   \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,
+            444,
+            825,
+            565
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            569,
+            705,
+            584
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            588,
+            825,
+            678
+        ],
+        "page_idx": 12
+    }
+]

parse/train/B1EPYJ-C-/B1EPYJ-C-.md

@@ -0,0 +1,194 @@
+# FEDERATED LEARNING: STRATEGIES FOR IMPROVING COMMUNICATION EFFICIENCY
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Federated Learning is a machine learning setting where the goal is to train a highquality centralized model while training data remains distributed over a large number of clients each with unreliable and relatively slow network connections. We consider learning algorithms for this setting where on each round, each client independently computes an update to the current model based on its local data, and communicates this update to a central server, where the client-side updates are aggregated to compute a new global model. The typical clients in this setting are mobile phones, and communication efficiency is of the utmost importance.
+
+In this paper, we propose two ways to reduce the uplink communication costs: structured updates, where we directly learn an update from a restricted space parametrized using a smaller number of variables, e.g. either low-rank or a random mask; and sketched updates, where we learn a full model update and then compress it using a combination of quantization, random rotations, and subsampling before sending it to the server. Experiments on both convolutional and recurrent networks show that the proposed methods can reduce the communication cost by two orders of magnitude.
+
+# 1 INTRODUCTION
+
+As datasets grow larger and models more complex, training machine learning models increasingly requires distributing the optimization of model parameters over multiple machines. Existing machine learning algorithms are designed for highly controlled environments (such as data centers) where the data is distributed among machines in a balanced and i.i.d. fashion, and high-throughput networks are available.
+
+Recently, Federated Learning (and related decentralized approaches) (McMahan & Ramage, 2017; Konecnˇ y et al., 2016; McMahan et al., 2017; Shokri & Shmatikov, 2015) have been proposed as ´ an alternative setting: a shared global model is trained under the coordination of a central server, from a federation of participating devices. The participating devices (clients) are typically large in number and have slow or unstable internet connections. A principal motivating example for Federated Learning arises when the training data comes from users’ interaction with mobile applications. Federated Learning enables mobile phones to collaboratively learn a shared prediction model while keeping all the training data on device, decoupling the ability to do machine learning from the need to store the data in the cloud. The training data is kept locally on users’ mobile devices, and the devices are used as nodes performing computation on their local data in order to update a global model. This goes beyond the use of local models that make predictions on mobile devices, by bringing model training to the device as well. The above framework differs from conventional distributed machine learning (Reddi et al., 2016; Ma et al., 2017; Shamir et al., 2014; Zhang & Lin, 2015; Dean et al., 2012; Chilimbi et al., 2014) due to the very large number of clients, highly unbalanced and non-i.i.d. data available on each client, and relatively poor network connections. In this work, our focus is on the last constraint, since these unreliable and asymmetric connections pose a particular challenge to practical Federated Learning.
+
+For simplicity, we consider synchronized algorithms for Federated Learning where a typical round consists of the following steps:
+
+1. A subset of existing clients is selected, each of which downloads the current model.
+
+2. Each client in the subset computes an updated model based on their local data.
+
+3. The model updates are sent from the selected clients to the sever.   
+4. The server aggregates these models (typically by averaging) to construct an improved global model.
+
+A naive implementation of the above framework requires that each client sends a full model (or a full model update) back to the server in each round. For large models, this step is likely to be the bottleneck of Federated Learning due to multiple factors. One factor is the asymmetric property of internet connection speeds: the uplink is typically much slower than downlink. The US average broadband speed was 55.0Mbps download vs. 18.9Mbps upload, with some internet service providers being significantly more asymmetric, e.g., Xfinity at 125Mbps down vs. 15Mbps up (speedtest.net, 2016). Additionally, existing model compressions schemes such as Han et al. (2015) can reduce the bandwidth necessary to download the current model, and cryptographic protocols put in place to ensure no individual client’s update can be inspected before averaging with hundreds or thousands of other updates (Bonawitz et al., 2017) further increase the amount of bits that need to be uploaded.
+
+It is therefore important to investigate methods which can reduce the uplink communication cost. In this paper, we study two general approaches:
+
+• Structured updates, where we directly learn an update from a restricted space that can be parametrized using a smaller number of variables.   
+• Sketched updates, where we learn a full model update, then compress it before sending to the server.
+
+These approaches, explained in detail in Sections 2 and 3, can be combined, e.g., first learning a structured update and sketching it; we do not experiment with this combination in this work though.
+
+In the following, we formally describe the problem. The goal of Federated Learning is to learn a model with parameters embodied in a real matrix1 $\mathbf { W } \in \mathbf { \overline { { R } } } ^ { d _ { 1 } \times d _ { 2 } }$ from data stored across a large number of clients. We first provide a communication-naive version of the Federated Learning. In round $t ~ \geq 0$ , the server distributes the current model $\mathbf { W } _ { t }$ to a subset $S _ { t }$ of $n _ { t }$ clients. These clients independently update the model based on their local data. Let the updated local models be $\mathbf { W } _ { t } ^ { 1 } , \mathbf { W } _ { t } ^ { 2 } , \dots , \mathbf { W } _ { t } ^ { n _ { t } }$ , so the update of client $i$ can be written as $\mathbf { H } _ { t } ^ { i } : = \mathbf { W } _ { t } ^ { \dot { i } } - \mathbf { W } _ { t }$ , for $i \in S _ { t }$ . These updates could be a single gradient computed on the client, but typically will be the result of a more complex calculation, for example, multiple steps of stochastic gradient descent (SGD) taken on the client’s local dataset. In any case, each selected client then sends the update back to the sever, where the global update is computed by aggregating2 all the client-side updates:
+
+$$
+\begin{array} { r } { \mathbf { W } _ { t + 1 } = \mathbf { W } _ { t } + \eta _ { t } \mathbf { H } _ { t } , \qquad \mathbf { H } _ { t } : = \frac { 1 } { n _ { t } } \sum _ { i \in S _ { t } } \mathbf { H } _ { t } ^ { i } . } \end{array}
+$$
+
+The sever chooses the learning rate $\eta _ { t }$ . For simplicity, we choose $\eta _ { t } = 1$ .
+
+In Section 4, we describe Federated Learning for neural networks, where we use a separate 2D matrix $\mathbf { W }$ to represent the parameters of each layer. We suppose that W gets right-multiplied, i.e., $d _ { 1 }$ and $d _ { 2 }$ represent the output and input dimensions respectively. Note that the parameters of a fully connected layer are naturally represented as 2D matrices. However, the kernel of a convolutional layer is a 4D tensor of the shape $\# \mathrm { i n p u t } \times \mathrm { w i d t h } \times \mathrm { h e i g h t } \times \#$ output. In such a case, W is reshaped from the kernel to the shape $( \# \mathrm { i n p u t } \times \mathrm { w i d t h } \times \mathrm { h e i g h t } ) \times \# \mathrm { c }$ utput.
+
+Outline and summary. The goal of increasing communication efficiency of Federated Learning is to reduce the cost of sending $\bar { \mathbf { H } } _ { t } ^ { i }$ to the server, while learning from data stored across large number of devices with limited internet connection and availability for computation. We propose two general classes of approaches, structured updates and sketched updates. In the Experiments section, we evaluate the effect of these methods in training deep neural networks.
+
+In simulated experiments on CIFAR data, we investigate the effect of these techniques on the convergence of the Federated Averaging algorithm (McMahan et al., 2017). With only a slight degradation in convergence speed, we are able to reduce the total amount of data communicated by two orders of magnitude. This lets us obtain a good prediction accuracy with an all-convolutional model, while in total communicating less information than the size of the original CIFAR data. In a larger realistic experiment on user-partitioned text data, we show that we are able to efficiently train a recurrent neural network for next word prediction, before even using the data of every user once. Finally, we note that we achieve the best results including the preprocessing of updates with structured random rotations. Practical utility of this step is unique to our setting, as the cost of applying the random rotations would be dominant in typical parallel implementations of SGD, but is negligible, compared to the local training in Federated Learning.
+
+# 2 STRUCTURED UPDATE
+
+The first type of communication efficient update restricts the updates $\mathbf { H } _ { t } ^ { i }$ to have a pre-specified structure. Two types of structures are considered in the paper: low rank and random mask. It is important to stress that we train directly the updates of this structure, as opposed to approximating/sketching general updates with an object of a specific structure — which is discussed in Section 3.
+
+Low rank. We enforce every update to local model $\mathbf { H } _ { t } ^ { i } \in \mathbb { R } ^ { d _ { 1 } \times d _ { 2 } }$ to be a low rank matrix of rank at most $k$ , where $k$ is a fixed number. In order to do so, we express $\mathbf { H } _ { t } ^ { i }$ as the product of two matrices: $\mathbf { H } _ { t } ^ { i } = \mathbf { A } _ { t } ^ { i } \mathbf { B } _ { t } ^ { i }$ , where $\mathbf { A } _ { t } ^ { i } \in \mathbb { R } ^ { d _ { 1 } \times k }$ , $\mathbf { B } _ { t } ^ { i } \in \mathbb { R } ^ { k \times d _ { 2 } }$ . In subsequent computation, we generated $\mathbf { A } _ { t } ^ { i }$ randomly and consider a constant during a local training procedure, and we optimize only $\mathbf { B } _ { t } ^ { i }$ . Note that in practical implementation, $\mathbf { A } _ { t } ^ { i }$ can in this case be compressed in the form of a random seed and the clients only need to send trained $\mathbf { B } _ { t } ^ { i }$ to the server. Such approach immediately saves a factor of $d _ { 1 } / k$ in communication. We generate the matrix $\mathbf { A } _ { t } ^ { i }$ afresh in each round and for each client independently.
+
+We also tried fixing $\mathbf { B } _ { t } ^ { i }$ and training $\mathbf { A } _ { t } ^ { i }$ , as well as training both $\mathbf { A } _ { t } ^ { i }$ and $\mathbf { B } _ { t } ^ { i }$ ; neither performed as well. Our approach seems to perform as well as the best techniques considered in Denil et al. (2013), without the need of any hand-crafted features. An intuitive explanation for this observation is the following. We can interpret $\mathbf { B } _ { t } ^ { i }$ as a projection matrix, and $\mathbf { A } _ { t } ^ { i }$ as a reconstruction matrix. Fixing $\mathbf { A } _ { t } ^ { i }$ and optimizing for $\mathbf { B } _ { t } ^ { i }$ is akin to asking “Given a given random reconstruction, what is the projection that will recover most information?”. In this case, if the reconstruction is full-rank, the projection that recovers space spanned by top $k$ eigenvectors exists. However, if we randomly fix the projection and search for a reconstruction, we can be unlucky and the important subspaces might have been projected out, meaning that there is no reconstruction that will do as well as possible, or will be very hard to find.
+
+Random mask. We restrict the update $\mathbf { H } _ { t } ^ { i }$ to be a sparse matrix, following a pre-defined random sparsity pattern (i.e., a random mask). The pattern is generated afresh in each round and for each client independently. Similar to the low-rank approach, the sparse pattern can be fully specified by a random seed, and therefore it is only required to send the values of the non-zeros entries of $\mathbf { H } _ { t } ^ { i }$ , along with the seed.
+
+# 3 SKETCHED UPDATE
+
+The second type of updates addressing communication cost, which we call sketched, first computes the full $\mathbf { H } _ { t } ^ { i }$ during local training without any constraints, and then approximates, or encodes, the update in a (lossy) compressed form before sending to the server. The server decodes the updates before doing the aggregation. Such sketching methods have application in many domains (Woodruff, 2014). We experiment with multiple tools in order to perform the sketching, which are mutually compatible and can be used jointly:
+
+Subsampling. Instead of sending $\mathbf { H } _ { t } ^ { i }$ , each client only communicates matrix $\hat { \mathbf { H } } _ { t } ^ { i }$ which is formed from a random subset of the (scaled) values of $\mathbf { H } _ { t } ^ { i }$ . The server then averages the subsampled updates, producing the global update $\hat { { \bf H } } _ { t }$ . This can be done so that the average of the sampled updates is an unbiased estimator of the true average: $\mathbb { E } [ \hat { \mathbf { H } } _ { t } ] = \mathbf { H } _ { t }$ . Similar to the random mask structured update, the mask is randomized independently for each client in each round, and the mask itself can be stored as a synchronized seed.
+
+Probabilistic quantization. Another way of compressing the updates is by quantizing the weights.
+
+We first describe the algorithm of quantizing each scalar to one bit. Consider the update $\mathbf { H } _ { t } ^ { i }$ , let $h = ( h _ { 1 } , \ldots , h _ { d _ { 1 } \times d _ { 2 } } ) \bar { = } \mathrm { v e c } ( \mathbf { H } _ { t } ^ { i } )$ , and let $h _ { \operatorname* { m a x } } = \operatorname* { m a x } _ { j } ( h _ { j } )$ , $h _ { \operatorname* { m i n } } = \operatorname* { m i n } _ { j } ( h _ { j } )$ . The compressed update of $h$ , denoted by $\tilde { h }$ , is generated as follows:
+
+$$
+\tilde { h } _ { j } = \left\{ \begin{array} { c c c } { h _ { \operatorname* { m a x } } , } & { \mathrm { w i t h ~ p r o b a b i l i t y } } & { \frac { h _ { j } - h _ { \operatorname* { m i n } } } { h _ { \operatorname* { m a x } } - h _ { \operatorname* { m i n } } } } \\ { h _ { \operatorname* { m i n } } , } & { \mathrm { w i t h ~ p r o b a b i l i t y } } & { \frac { h _ { \operatorname* { m a x } } - h _ { j } } { h _ { \operatorname* { m a x } } - h _ { \operatorname* { m i n } } } } \end{array} \right. .
+$$
+
+It is easy to show that $\tilde { h }$ is an unbiased estimator of $h$ . This method provides $3 2 \times$ of compression compared to a 4 byte float. The error incurred with this compression scheme was analysed for instance in Suresh et al. (2017), and is a special case of protocol proposed in Konecnˇ y & Richt ´ arik ´ (2016).
+
+One can also generalize the above to more than 1 bit for each scalar. For $b$ -bit quantization, we first equally divide $[ h _ { \operatorname* { m i n } } , h _ { \operatorname* { m a x } } ]$ into $2 ^ { b }$ intervals. Suppose $h _ { i }$ falls in the interval bounded by $h ^ { \prime }$ and $h ^ { \prime \prime }$ . The quantization operates by replacing $h _ { \mathrm { m i n } }$ and $h _ { \mathrm { m a x } }$ of the above equation by $h ^ { \prime }$ and $h ^ { \prime \prime }$ , respectively. Parameter $b$ then allows for simple way of balancing accuracy and communication costs.
+
+Another quantization approach also motivated by reduction of communication while averaging vectors was recently proposed in Alistarh et al. (2016). Incremental, randomized and distributed optimization algorithms can be similarly analysed in a quantized updates setting (Rabbat & Nowak, 2005; Golovin et al., 2013; Gamal & Lai, 2016).
+
+Improving the quantization by structured random rotations. The above 1-bit and multi-bit quantization approach work best when the scales are approximately equal across different dimensions.
+
+For example, when max $= ~ 1$ and $\operatorname* { m i n } { } = - 1$ and most of values are 0, the 1-bit quantization will lead to a large error. We note that applying a random rotation on $h$ before the quantization (multiplying $h$ by a random orthogonal matrix) solves this issue. This claim has been theoretically supported in Suresh et al. (2017). In that work, is shows that the structured random rotation can reduce the quantization error by a factor of $\mathcal { O } ( d / \log d )$ , where $d$ is the dimension of $h$ . We will show its practical utility in the next section.
+
+In the decoding phase, the server needs to perform the inverse rotation before aggregating all the updates. Note that in practice, the dimension of $h$ can easily be as high as $d = \bar { 1 0 ^ { 6 } }$ or more, and it is computationally prohibitive to generate $( \mathcal { O } ( d ^ { 3 } ) )$ and apply $( \mathcal { O } ( d ^ { 2 } ) )$ a general rotation matrix. Same as Suresh et al. (2017), we use a type of structured rotation matrix which is the product of a Walsh-Hadamard matrix and a binary diagonal matrix. This reduces the computational complexity of generating and applying the matrix to $\bar { \mathcal { O } } ( d )$ and ${ \mathcal { O } } ( d \log d )$ , which is negligible compared to the local training within Federated Learning.
+
+# 4 EXPERIMENTS
+
+We conducted experiments using Federated Learning to train deep neural networks for two different tasks. First, we experiment with the CIFAR-10 image classification task (Krizhevsky, 2009) with convolutional networks and artificially partitioned dataset, and explore properties of our proposed algorithms in detail. Second, we use more realistic scenario for Federated Learning — the public Reddit post data (Google BigQuery), to train a recurrent network for next word prediction.
+
+The Reddit dataset is particularly useful for simulated Federated Learning experiments, as it comes with natural per-user data partition (by author of the posts). This includes many of the characteristics expected to arise in practical implementation. For example, many users having relatively few data points, and words used by most users are clustered around a specific topic of interest of the particular user.
+
+In all of our experiments, we employ the Federated Averaging algorithm (McMahan et al., 2017), which significantly decreases the number of rounds of communication required to train a good model. Nevertheless, we expect our techniques will show a similar reduction in communication costs when applied to a synchronous distributed SGD, see for instance Alistarh et al. (2016). For Federated Averaging, on each round we select multiple clients uniformly at random, each of which performs several epochs of SGD with a learning rate of $\eta$ on their local dataset. For the structured updates, SGD is restricted to only update in the restricted space, that is, only the entries of $\mathbf { B } _ { t } ^ { i }$ for low-rank updates and the unmasked entries for the random-mask technique. From this updated model we compute the updates for each layer $\mathbf { H } _ { t } ^ { i }$ . In all cases, we run the experiments with a range of choices of learning rate, and report the best result.
+
+![](images/c86d7a1bc34a8cb47c173e90e8061180181b9ec2d48241acdcc0a6f928b4516c.jpg)  
+Figure 1: Structured updates with the CIFAR data for size reduction various modes. Low rank updates in top row, random mask updates in bottom row.
+
+# 4.1 CONVOLUTIONAL MODELS ON THE CIFAR-10 DATASET
+
+In this section we use the CIFAR-10 dataset to investigate the properties of our proposed methods as part of Federated Averaging algorithm.
+
+There are 50 000 training examples in the CIFAR-10 dataset, which we randomly partitioned into 100 clients each containing 500 training examples. The model architecture we used was the allconvolutional model taken from what is described as “Model $\mathbf { { C } } ^ { \ast }$ in Springenberg et al. (2014), for a total of over $1 0 ^ { 6 }$ parameters. While this model is not the state-of-the-art, it is sufficient for our needs, as our goal is to evaluate our compression methods, not to achieve the best possible accuracy on this task.
+
+The model has 9 convolutional layers, first and last of which have significantly fewer parameters than the others. Hence, in this whole section, when we try to reduce the size the individual updates, we only compress the inner 7 layers, each of which with the same parameter3. We denote this by keyword ‘mode’, for all approaches. For low rank updates, ‘mode $= 2 5 \%$ ’ refers to the rank of the update being set to $1 / 4$ of rank of the full layer transformation, for random mask or sketching, this refers to all but $2 5 \%$ of the parameters being zeroed out.
+
+In the first experiment, summarized in Figure 1, we compare the two types of structured updates introduced in Section 2 — low rank in the top row and random mask in the bottom row. The main message is that random mask performs significantly better than low rank, as we reduce the size of the updates. In particular, the convergence speed of random mask seems to be essentially unaffected when measured in terms of number of rounds. Consequently, if the goal was to only minimize the upload size, the version with reduced update size is a clear winner, as seen in the right column.
+
+In Figure 2, we compare the performance of structured and sketched updates, without any quantization. Since in the above, the structured random mask updates performed better, we omit low rank update for clarity from this comparison. We compare this with the performance of the sketched updates, with and without preprocessing the update using random rotation, as described in Section 3, and for two different modes. We denote the randomized Hadamard rotation by ‘HD’, and no rotation by ‘I’.
+
+![](images/9e7e8cebe5e565d2769a9865c860ded6318bb53db1d96993a9a66b6b72d98263.jpg)  
+Figure 2: Comparison of structured random mask updates and sketched updates without quantization on the CIFAR data.
+
+![](images/b97f7821c5c4e8e3b4c7dcc69bfe26cda7fddcaaa73f847d7fb0af85c0744145.jpg)  
+Figure 3: Comparison of sketched updates, combining preprocessing the updates with rotations, quantization and subsampling on the CIFAR data.
+
+The intuitive expectation is that directly learning the structured random mask updates should be better than learning an unstructured update, which is then sketched to be represented with the same number of parameters. This is because by sketching we throw away some of the information obtained during training. The fact that with sketching the updates, we should converge to a slightly lower accuracy can be theoretically supported, using analogous argument as carefully stated in (Alistarh et al., 2016), since sketching the updates increases the variance directly appearing in convergence analysis. We see this behaviour when using the structured random mask updates, we are able to eventually converge to slightly higher accuracy. However, we also see that with sketching the updates, we are able to attain modest accuracy (e.g. $8 5 \%$ ) slightly faster.
+
+In the last experiment on CIFAR data, we focus on interplay of all three elements introduced in Section 3 — subsampling, quantization and random rotations. Note that combination of all these tools will enable higher compression rate than in the above experiments. Each pair of plots in Figure 3 focuses on particular mode (subsampling), and in each of them we plot performance with different bits used in quantization, with or without the random rotations. What we can see consistently in all plots, is that the random rotation improves the performance. In general, the behaviour of the algorithm is less stable without the rotations, particularly with small number of quantization bits and smaller modes.
+
+In order to highlight the potential of communication savings, note that by preprocessing with the random rotation, sketching out all but $6 . 2 5 \%$ elements of the update and using 2 bits for quantization, we get only a minor drop in convergence, while saving factor of 256 in terms of bits needed to represent the updates to individual layers. Finally, if we were interested in minimizing the amount of data uploaded, we can obtain a modest accuracy, say $8 5 \%$ , while in total communicating less than half of what would be required to upload the original data.
+
+# 4.2 LSTM NEXT-WORD PREDICTION ON REDDIT DATA
+
+We constructed the dataset for simulating Federated Learning based on the data containing publicly available posts/comments on Reddit (Google BigQuery), as described by Al-Rfou et al. (2016). Critically for our purposes, each post in the database is keyed by an author, so we can group the data by these keys, making the assumption of one client device per author. Some authors have a very large number of posts, but in each round of FedAvg we process at most 32 000 tokens per user. We omit authors with fewer than 1600 tokens, since there is constant overhead per client in the simulation, and users with little data don’t contribute much to training. This leaves a dataset of 763 430 users, with an average of 24 791 tokens per user. For evaluation, we use a relatively small test set of 75 122 tokens formed from random held-out posts.
+
+Based on this data, we train a LSTM next word prediction model. The model is trained to predict the next word given the current word and a state vector passed from the previous time step. The model works as follows: word $s _ { t }$ is mapped to an embedding vector $e _ { t } \in \mathbb { R } ^ { 9 6 }$ , by looking up the word in a dictionary of 10 017 words (tokens). $e _ { t }$ is then composed with the state emitted by the model in the previous time step $s _ { t 1 } \in \mathbb { R } ^ { 2 5 6 }$ to emit a new state vector $s _ { t }$ and an “output embedding” $o _ { t } \in \mathbf { R } ^ { 9 6 }$ . The output embedding is scored against the embedding of each item in the vocabulary via inner product, before being normalized via softmax to compute a probability distribution over the vocabulary. Like other standard language models, we treat every input sequence as beginning with an implicit “BOS” (beginning of sequence) token and ending with an implicit “EOS” (end of sequence) token. Unlike standard LSTM language models, our model uses the same learned embedding for both the embedding and softmax layers. This reduces the size of the model by about $40 \%$ for a small decrease in model quality, an advantageous tradeoff for mobile applications. Another change from many standard LSTM RNN approaches is that we train these models to restrict the word embeddings to have a fixed L2 norm of 1.0, a modification found to improve convergence time. In total the model has 1.35M parameters.
+
+In order to reduce the size of the update, we sketch all the model variables except some small variables (such as biases) which consume less than $0 . 0 1 \%$ of memory. We evaluate using AccuracyTop1, the probability that the word to which the model assigns highest probability is correct. We always count it as a mistake if the true next word is not in the dictionary, even if the model predicts ‘unknown’.
+
+In Figure 4, we run the Federated Averaging algorithm on Reddit data, with various parameters that specify the sketching. In every iteration, we randomly sample 50 users that compute update based on the data available locally, sketch it, and all the updates are averaged. Experiments with sampling 10, 20, and 100 clients in each round provided similar conclusions as the following.
+
+In all of the plots, we combine the three components for sketching the updates introduced in Section 3. First, we apply a random rotation to preprocess the local update. Further, ‘sketch fraction’ set to either 0.1 or 1, denotes fraction of the elements of the update being subsampled.
+
+In the left column, we plot this against the number of iterations of the algorithm. First, we can see that the effect of preprocessing with the random rotation has significantly positive effect, particularly with small number of quantization bits. It is interesting to see that for all choices of the subsampling ratio, randomized Hadamard transform with quantization into 2 bits does not incur any loss in performance. An important measure to highlight is the number of rounds displayed in the plots is 2000. Since we sample 50 users per round, this experiment would not touch the data of most users even once! This further strengthens the claim that applying Federated Learning in realistic setting is possible without affecting the user experience in any way.
+
+![](images/7c478fbe9950e9655b5cd7577dda68b7b90ea639379e66c20ce989ea66fef5a5.jpg)  
+Figure 4: Comparison of sketched updates, training a recurrent model on the Reddit data, randomly sampling 50 clients per round.
+
+![](images/dbe30e167e6e5114869bc54a27ea60da92be0de1a8a670768d619a9862913202.jpg)  
+Figure 5: Effect of the number of clients used in training per round.
+
+In the right column, we plot the same data against the total number of megabytes that would need to be communicated by clients back to the server. From these plots, it is clear that if one needed to primarily minimize this metric, the techniques we propose are extremely efficient. Of course, neither of these objectives is what we would optimize for in a practical application. Nevertheless, given the current lack of experience with issues inherent in large scale deployment of Federated Learning, we believe that these are useful proxies for what will be relevant in a practical application.
+
+Finally, in Figure 5, we study the effect of number of clients we use in a single round on the convergence. We run the Federated Averaging algorithm for a fixed number of rounds (500 and 2500) with varying number of clients per round, quantize updates to 1 bit, and plot the resulting accuracy. We see that with sufficient number of clients per round, 1024 in this case, we can reduce the fraction of subsampled elements down to $1 \%$ , with only minor drop in accuracy compared to $1 0 \%$ . This suggests an important and practical tradeoff in the federated setting: one can select more clients in each round while having each of them communicate less (e.g., more aggressive subsampling), and obtain the same accuracy as using fewer clients, but having each of them communicate more. The former may be preferable when many clients are available, but each has very limited upload bandwidth — which is a setting common in practice.
+
+# REFERENCES
+
+Rami Al-Rfou, Marc Pickett, Javier Snaider, Yun-hsuan Sung, Brian Strope, and Ray Kurzweil. Conversational contextual cues: The case of personalization and history for response ranking. arXiv:1606.00372, 2016.
+
+Dan Alistarh, Jerry Li, Ryota Tomioka, and Milan Vojnovic. QSGD: Randomized quantization for communication-optimal stochastic gradient descent. arXiv:1610.02132, 2016.
+
+Keith Bonawitz, Vladimir Ivanov, Ben Kreuter, Antonio Marcedone, H. Brendan McMahan, Sarvar Patel, Daniel Ramage, Aaron Segal, and Karn Seth. Practical secure aggregation for privacy preserving machine learning. In ACM Conference on Computer and Communications Security (ACM CCS), 2017.
+
+Trishul Chilimbi, Yutaka Suzue, Johnson Apacible, and Karthik Kalyanaraman. Project adam: Building an efficient and scalable deep learning training system. In 11th USENIX Symposium on Operating Systems Design and Implementation (OSDI 14), pp. 571–582, 2014.
+
+Jeffrey Dean, Greg Corrado, Rajat Monga, Kai Chen, Matthieu Devin, Mark Mao, Andrew Senior, Paul Tucker, Ke Yang, Quoc V Le, et al. Large scale distributed deep networks. In NIPS, pp. 1223–1231, 2012.
+
+Misha Denil, Babak Shakibi, Laurent Dinh, Nando de Freitas, et al. Predicting parameters in deep learning. In NIPS, pp. 2148–2156, 2013.
+
+Mostafa El Gamal and Lifeng Lai. On randomized distributed coordinate descent with quantized updates. arXiv:1609.05539, 2016.
+
+Daniel Golovin, D. Sculley, H. Brendan McMahan, and Michael Young. Large-scale learning with less ram via randomization. In ICML, 2013.
+
+Google BigQuery. Reddit comments dataset. BigQuery, 2016. https://bigquery.cloud.google. com/dataset/fh-bigquery.
+
+Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. arXiv preprint arXiv:1510.00149, 2015.
+
+Jakub Konecnˇ y and Peter Richt ´ arik. Randomized distributed mean estimation: Accuracy vs communication. ´ arXiv:1611.07555, 2016.
+
+Jakub Konecnˇ y, H. Brendan McMahan, Daniel Ramage, and Peter Richt ´ arik. Federated optimization: Dis- ´ tributed machine learning for on-device intelligence. arXiv preprint arXiv:1610.02527, 2016.
+
+Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, 2009.
+
+Chenxin Ma, Jakub Konecnˇ y, Martin Jaggi, Virginia Smith, Michael I Jordan, Peter Richt ´ arik, and Martin ´ Taka´c. Distributed optimization with arbitrary local solvers. ˇ Optimization Methods & Software, 32(4): 813–848, 2017.
+
+H. Brendan McMahan and Daniel Ramage. Federated learning: Collaborative machine learning without centralized training data. https://research.googleblog.com/2017/04/federated-learning-collaborative.html, 2017.
+
+H. Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Aguera y Arcas. Communication-efficient learning of deep networks from decentralized data. In Proceedings of the 20th International Conference on Artificial Intelligence and Statistics (AISTATS), 2017.
+
+M.G. Rabbat and R.D. Nowak. Quantized incremental algorithms for distributed optimization. IEEE Journal on Selected Areas in Communications, 23(4):798–808, 2005.
+
+Sashank J Reddi, Jakub Konecnˇ y, Peter Richt ´ arik, Barnab ´ as P ´ ocz ´ os, and Alex Smola. AIDE: Fast and commu-´ nication efficient distributed optimization. arXiv:1608.06879, 2016.
+
+Ohad Shamir, Nathan Srebro, and Tong Zhang. Communication-efficient distributed optimization using an approximate Newton-type method. In ICML, pp. 1000–1008, 2014.
+
+Reza Shokri and Vitaly Shmatikov. Privacy-preserving deep learning. In Proceedings of the 22Nd ACM SIGSAC Conference on Computer and Communications Security, CCS ’15, 2015.
+
+speedtest.net. Speedtest market report. http://www.speedtest.net/reports/united-states/, August 2016.
+
+Jost Tobias Springenberg, Alexey Dosovitskiy, Thomas Brox, and Martin Riedmiller. Striving for simplicity: The all convolutional net. arXiv:1412.6806, 2014.
+
+Ananda Theertha Suresh, Felix X. Yu, Sanjiv Kumar, and H. Brendan McMahan. Distributed mean estimation with limited communication. In Proceedings of the 34th International Conference on Machine Learning, pp. 3329–3337, 2017.
+
+David P. Woodruff. Sketching as a tool for numerical linear algebra. Foundations and Trends in Theoretical Computer Science, 10(12):1–157, 2014. ISSN 1551-305X. doi: 10.1561/0400000060.
+
+Yuchen Zhang and Xiao Lin. DiSCO: Distributed optimization for self-concordant empirical loss. In ICML, pp. 362–370, 2015.

parse/train/B1EPYJ-C-/B1EPYJ-C-_content_list.json

@@ -0,0 +1,1080 @@
+[
+    {
+        "type": "text",
+        "text": "FEDERATED LEARNING: STRATEGIES FOR IMPROVING COMMUNICATION EFFICIENCY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            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": "Federated Learning is a machine learning setting where the goal is to train a highquality centralized model while training data remains distributed over a large number of clients each with unreliable and relatively slow network connections. We consider learning algorithms for this setting where on each round, each client independently computes an update to the current model based on its local data, and communicates this update to a central server, where the client-side updates are aggregated to compute a new global model. The typical clients in this setting are mobile phones, and communication efficiency is of the utmost importance. ",
+        "bbox": [
+            233,
+            267,
+            764,
+            378
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose two ways to reduce the uplink communication costs: structured updates, where we directly learn an update from a restricted space parametrized using a smaller number of variables, e.g. either low-rank or a random mask; and sketched updates, where we learn a full model update and then compress it using a combination of quantization, random rotations, and subsampling before sending it to the server. Experiments on both convolutional and recurrent networks show that the proposed methods can reduce the communication cost by two orders of magnitude. ",
+        "bbox": [
+            233,
+            382,
+            764,
+            492
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            522,
+            336,
+            537
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "As datasets grow larger and models more complex, training machine learning models increasingly requires distributing the optimization of model parameters over multiple machines. Existing machine learning algorithms are designed for highly controlled environments (such as data centers) where the data is distributed among machines in a balanced and i.i.d. fashion, and high-throughput networks are available. ",
+        "bbox": [
+            174,
+            554,
+            823,
+            623
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently, Federated Learning (and related decentralized approaches) (McMahan & Ramage, 2017; Konecnˇ y et al., 2016; McMahan et al., 2017; Shokri & Shmatikov, 2015) have been proposed as ´ an alternative setting: a shared global model is trained under the coordination of a central server, from a federation of participating devices. The participating devices (clients) are typically large in number and have slow or unstable internet connections. A principal motivating example for Federated Learning arises when the training data comes from users’ interaction with mobile applications. Federated Learning enables mobile phones to collaboratively learn a shared prediction model while keeping all the training data on device, decoupling the ability to do machine learning from the need to store the data in the cloud. The training data is kept locally on users’ mobile devices, and the devices are used as nodes performing computation on their local data in order to update a global model. This goes beyond the use of local models that make predictions on mobile devices, by bringing model training to the device as well. The above framework differs from conventional distributed machine learning (Reddi et al., 2016; Ma et al., 2017; Shamir et al., 2014; Zhang & Lin, 2015; Dean et al., 2012; Chilimbi et al., 2014) due to the very large number of clients, highly unbalanced and non-i.i.d. data available on each client, and relatively poor network connections. In this work, our focus is on the last constraint, since these unreliable and asymmetric connections pose a particular challenge to practical Federated Learning. ",
+        "bbox": [
+            174,
+            632,
+            825,
+            867
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "For simplicity, we consider synchronized algorithms for Federated Learning where a typical round consists of the following steps: ",
+        "bbox": [
+            174,
+            875,
+            821,
+            902
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1. A subset of existing clients is selected, each of which downloads the current model. ",
+        "bbox": [
+            212,
+            909,
+            776,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2. Each client in the subset computes an updated model based on their local data. ",
+        "bbox": [
+            210,
+            103,
+            743,
+            117
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3. The model updates are sent from the selected clients to the sever.   \n4. The server aggregates these models (typically by averaging) to construct an improved global model. ",
+        "bbox": [
+            210,
+            108,
+            825,
+            159
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A naive implementation of the above framework requires that each client sends a full model (or a full model update) back to the server in each round. For large models, this step is likely to be the bottleneck of Federated Learning due to multiple factors. One factor is the asymmetric property of internet connection speeds: the uplink is typically much slower than downlink. The US average broadband speed was 55.0Mbps download vs. 18.9Mbps upload, with some internet service providers being significantly more asymmetric, e.g., Xfinity at 125Mbps down vs. 15Mbps up (speedtest.net, 2016). Additionally, existing model compressions schemes such as Han et al. (2015) can reduce the bandwidth necessary to download the current model, and cryptographic protocols put in place to ensure no individual client’s update can be inspected before averaging with hundreds or thousands of other updates (Bonawitz et al., 2017) further increase the amount of bits that need to be uploaded. ",
+        "bbox": [
+            173,
+            166,
+            825,
+            305
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "It is therefore important to investigate methods which can reduce the uplink communication cost. In this paper, we study two general approaches: ",
+        "bbox": [
+            174,
+            313,
+            821,
+            340
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Structured updates, where we directly learn an update from a restricted space that can be parametrized using a smaller number of variables.   \n• Sketched updates, where we learn a full model update, then compress it before sending to the server. ",
+        "bbox": [
+            217,
+            348,
+            825,
+            404
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "These approaches, explained in detail in Sections 2 and 3, can be combined, e.g., first learning a structured update and sketching it; we do not experiment with this combination in this work though. ",
+        "bbox": [
+            176,
+            410,
+            823,
+            439
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the following, we formally describe the problem. The goal of Federated Learning is to learn a model with parameters embodied in a real matrix1 $\\mathbf { W } \\in \\mathbf { \\overline { { R } } } ^ { d _ { 1 } \\times d _ { 2 } }$ from data stored across a large number of clients. We first provide a communication-naive version of the Federated Learning. In round $t ~ \\geq 0$ , the server distributes the current model $\\mathbf { W } _ { t }$ to a subset $S _ { t }$ of $n _ { t }$ clients. These clients independently update the model based on their local data. Let the updated local models be $\\mathbf { W } _ { t } ^ { 1 } , \\mathbf { W } _ { t } ^ { 2 } , \\dots , \\mathbf { W } _ { t } ^ { n _ { t } }$ , so the update of client $i$ can be written as $\\mathbf { H } _ { t } ^ { i } : = \\mathbf { W } _ { t } ^ { \\dot { i } } - \\mathbf { W } _ { t }$ , for $i \\in S _ { t }$ . These updates could be a single gradient computed on the client, but typically will be the result of a more complex calculation, for example, multiple steps of stochastic gradient descent (SGD) taken on the client’s local dataset. In any case, each selected client then sends the update back to the sever, where the global update is computed by aggregating2 all the client-side updates: ",
+        "bbox": [
+            173,
+            445,
+            825,
+            585
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/14b1c3ea74c17845d7aae07ac5c06874154e0e79da4acda959e89f05ed793d14.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf { W } _ { t + 1 } = \\mathbf { W } _ { t } + \\eta _ { t } \\mathbf { H } _ { t } , \\qquad \\mathbf { H } _ { t } : = \\frac { 1 } { n _ { t } } \\sum _ { i \\in S _ { t } } \\mathbf { H } _ { t } ^ { i } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            589,
+            661,
+            611
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The sever chooses the learning rate $\\eta _ { t }$ . For simplicity, we choose $\\eta _ { t } = 1$ . ",
+        "bbox": [
+            179,
+            616,
+            653,
+            631
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In Section 4, we describe Federated Learning for neural networks, where we use a separate 2D matrix $\\mathbf { W }$ to represent the parameters of each layer. We suppose that W gets right-multiplied, i.e., $d _ { 1 }$ and $d _ { 2 }$ represent the output and input dimensions respectively. Note that the parameters of a fully connected layer are naturally represented as 2D matrices. However, the kernel of a convolutional layer is a 4D tensor of the shape $\\# \\mathrm { i n p u t } \\times \\mathrm { w i d t h } \\times \\mathrm { h e i g h t } \\times \\#$ output. In such a case, W is reshaped from the kernel to the shape $( \\# \\mathrm { i n p u t } \\times \\mathrm { w i d t h } \\times \\mathrm { h e i g h t } ) \\times \\# \\mathrm { c }$ utput. ",
+        "bbox": [
+            174,
+            636,
+            825,
+            720
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Outline and summary. The goal of increasing communication efficiency of Federated Learning is to reduce the cost of sending $\\bar { \\mathbf { H } } _ { t } ^ { i }$ to the server, while learning from data stored across large number of devices with limited internet connection and availability for computation. We propose two general classes of approaches, structured updates and sketched updates. In the Experiments section, we evaluate the effect of these methods in training deep neural networks. ",
+        "bbox": [
+            174,
+            727,
+            825,
+            797
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In simulated experiments on CIFAR data, we investigate the effect of these techniques on the convergence of the Federated Averaging algorithm (McMahan et al., 2017). With only a slight degradation in convergence speed, we are able to reduce the total amount of data communicated by two orders of magnitude. This lets us obtain a good prediction accuracy with an all-convolutional model, while in total communicating less information than the size of the original CIFAR data. In a larger realistic experiment on user-partitioned text data, we show that we are able to efficiently train a recurrent neural network for next word prediction, before even using the data of every user once. Finally, we note that we achieve the best results including the preprocessing of updates with structured random rotations. Practical utility of this step is unique to our setting, as the cost of applying the random rotations would be dominant in typical parallel implementations of SGD, but is negligible, compared to the local training in Federated Learning. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 STRUCTURED UPDATE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            213,
+            392,
+            229
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The first type of communication efficient update restricts the updates $\\mathbf { H } _ { t } ^ { i }$ to have a pre-specified structure. Two types of structures are considered in the paper: low rank and random mask. It is important to stress that we train directly the updates of this structure, as opposed to approximating/sketching general updates with an object of a specific structure — which is discussed in Section 3. ",
+        "bbox": [
+            174,
+            248,
+            825,
+            319
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Low rank. We enforce every update to local model $\\mathbf { H } _ { t } ^ { i } \\in \\mathbb { R } ^ { d _ { 1 } \\times d _ { 2 } }$ to be a low rank matrix of rank at most $k$ , where $k$ is a fixed number. In order to do so, we express $\\mathbf { H } _ { t } ^ { i }$ as the product of two matrices: $\\mathbf { H } _ { t } ^ { i } = \\mathbf { A } _ { t } ^ { i } \\mathbf { B } _ { t } ^ { i }$ , where $\\mathbf { A } _ { t } ^ { i } \\in \\mathbb { R } ^ { d _ { 1 } \\times k }$ , $\\mathbf { B } _ { t } ^ { i } \\in \\mathbb { R } ^ { k \\times d _ { 2 } }$ . In subsequent computation, we generated $\\mathbf { A } _ { t } ^ { i }$ randomly and consider a constant during a local training procedure, and we optimize only $\\mathbf { B } _ { t } ^ { i }$ . Note that in practical implementation, $\\mathbf { A } _ { t } ^ { i }$ can in this case be compressed in the form of a random seed and the clients only need to send trained $\\mathbf { B } _ { t } ^ { i }$ to the server. Such approach immediately saves a factor of $d _ { 1 } / k$ in communication. We generate the matrix $\\mathbf { A } _ { t } ^ { i }$ afresh in each round and for each client independently. ",
+        "bbox": [
+            173,
+            324,
+            825,
+            438
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We also tried fixing $\\mathbf { B } _ { t } ^ { i }$ and training $\\mathbf { A } _ { t } ^ { i }$ , as well as training both $\\mathbf { A } _ { t } ^ { i }$ and $\\mathbf { B } _ { t } ^ { i }$ ; neither performed as well. Our approach seems to perform as well as the best techniques considered in Denil et al. (2013), without the need of any hand-crafted features. An intuitive explanation for this observation is the following. We can interpret $\\mathbf { B } _ { t } ^ { i }$ as a projection matrix, and $\\mathbf { A } _ { t } ^ { i }$ as a reconstruction matrix. Fixing $\\mathbf { A } _ { t } ^ { i }$ and optimizing for $\\mathbf { B } _ { t } ^ { i }$ is akin to asking “Given a given random reconstruction, what is the projection that will recover most information?”. In this case, if the reconstruction is full-rank, the projection that recovers space spanned by top $k$ eigenvectors exists. However, if we randomly fix the projection and search for a reconstruction, we can be unlucky and the important subspaces might have been projected out, meaning that there is no reconstruction that will do as well as possible, or will be very hard to find. ",
+        "bbox": [
+            174,
+            443,
+            825,
+            582
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Random mask. We restrict the update $\\mathbf { H } _ { t } ^ { i }$ to be a sparse matrix, following a pre-defined random sparsity pattern (i.e., a random mask). The pattern is generated afresh in each round and for each client independently. Similar to the low-rank approach, the sparse pattern can be fully specified by a random seed, and therefore it is only required to send the values of the non-zeros entries of $\\mathbf { H } _ { t } ^ { i }$ , along with the seed. ",
+        "bbox": [
+            174,
+            589,
+            825,
+            660
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 SKETCHED UPDATE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            685,
+            370,
+            702
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The second type of updates addressing communication cost, which we call sketched, first computes the full $\\mathbf { H } _ { t } ^ { i }$ during local training without any constraints, and then approximates, or encodes, the update in a (lossy) compressed form before sending to the server. The server decodes the updates before doing the aggregation. Such sketching methods have application in many domains (Woodruff, 2014). We experiment with multiple tools in order to perform the sketching, which are mutually compatible and can be used jointly: ",
+        "bbox": [
+            174,
+            720,
+            825,
+            805
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Subsampling. Instead of sending $\\mathbf { H } _ { t } ^ { i }$ , each client only communicates matrix $\\hat { \\mathbf { H } } _ { t } ^ { i }$ which is formed from a random subset of the (scaled) values of $\\mathbf { H } _ { t } ^ { i }$ . The server then averages the subsampled updates, producing the global update $\\hat { { \\bf H } } _ { t }$ . This can be done so that the average of the sampled updates is an unbiased estimator of the true average: $\\mathbb { E } [ \\hat { \\mathbf { H } } _ { t } ] = \\mathbf { H } _ { t }$ . Similar to the random mask structured update, the mask is randomized independently for each client in each round, and the mask itself can be stored as a synchronized seed. ",
+        "bbox": [
+            174,
+            813,
+            825,
+            902
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Probabilistic quantization. Another way of compressing the updates is by quantizing the weights. ",
+        "bbox": [
+            173,
+            909,
+            820,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We first describe the algorithm of quantizing each scalar to one bit. Consider the update $\\mathbf { H } _ { t } ^ { i }$ , let $h = ( h _ { 1 } , \\ldots , h _ { d _ { 1 } \\times d _ { 2 } } ) \\bar { = } \\mathrm { v e c } ( \\mathbf { H } _ { t } ^ { i } )$ , and let $h _ { \\operatorname* { m a x } } = \\operatorname* { m a x } _ { j } ( h _ { j } )$ , $h _ { \\operatorname* { m i n } } = \\operatorname* { m i n } _ { j } ( h _ { j } )$ . The compressed update of $h$ , denoted by $\\tilde { h }$ , is generated as follows: ",
+        "bbox": [
+            174,
+            103,
+            825,
+            148
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f5aefc8161a54d49835587de0baf734f9f459ea9268d824b93635c930ff6a483.jpg",
+        "text": "$$\n\\tilde { h } _ { j } = \\left\\{ \\begin{array} { c c c } { h _ { \\operatorname* { m a x } } , } & { \\mathrm { w i t h ~ p r o b a b i l i t y } } & { \\frac { h _ { j } - h _ { \\operatorname* { m i n } } } { h _ { \\operatorname* { m a x } } - h _ { \\operatorname* { m i n } } } } \\\\ { h _ { \\operatorname* { m i n } } , } & { \\mathrm { w i t h ~ p r o b a b i l i t y } } & { \\frac { h _ { \\operatorname* { m a x } } - h _ { j } } { h _ { \\operatorname* { m a x } } - h _ { \\operatorname* { m i n } } } } \\end{array} \\right. .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            155,
+            656,
+            199
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "It is easy to show that $\\tilde { h }$ is an unbiased estimator of $h$ . This method provides $3 2 \\times$ of compression compared to a 4 byte float. The error incurred with this compression scheme was analysed for instance in Suresh et al. (2017), and is a special case of protocol proposed in Konecnˇ y & Richt ´ arik ´ (2016). ",
+        "bbox": [
+            174,
+            207,
+            825,
+            263
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "One can also generalize the above to more than 1 bit for each scalar. For $b$ -bit quantization, we first equally divide $[ h _ { \\operatorname* { m i n } } , h _ { \\operatorname* { m a x } } ]$ into $2 ^ { b }$ intervals. Suppose $h _ { i }$ falls in the interval bounded by $h ^ { \\prime }$ and $h ^ { \\prime \\prime }$ . The quantization operates by replacing $h _ { \\mathrm { m i n } }$ and $h _ { \\mathrm { m a x } }$ of the above equation by $h ^ { \\prime }$ and $h ^ { \\prime \\prime }$ , respectively. Parameter $b$ then allows for simple way of balancing accuracy and communication costs. ",
+        "bbox": [
+            173,
+            270,
+            825,
+            340
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Another quantization approach also motivated by reduction of communication while averaging vectors was recently proposed in Alistarh et al. (2016). Incremental, randomized and distributed optimization algorithms can be similarly analysed in a quantized updates setting (Rabbat & Nowak, 2005; Golovin et al., 2013; Gamal & Lai, 2016). ",
+        "bbox": [
+            173,
+            347,
+            825,
+            404
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Improving the quantization by structured random rotations. The above 1-bit and multi-bit quantization approach work best when the scales are approximately equal across different dimensions. ",
+        "bbox": [
+            174,
+            410,
+            821,
+            439
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For example, when max $= ~ 1$ and $\\operatorname* { m i n } { } = - 1$ and most of values are 0, the 1-bit quantization will lead to a large error. We note that applying a random rotation on $h$ before the quantization (multiplying $h$ by a random orthogonal matrix) solves this issue. This claim has been theoretically supported in Suresh et al. (2017). In that work, is shows that the structured random rotation can reduce the quantization error by a factor of $\\mathcal { O } ( d / \\log d )$ , where $d$ is the dimension of $h$ . We will show its practical utility in the next section. ",
+        "bbox": [
+            173,
+            445,
+            825,
+            529
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the decoding phase, the server needs to perform the inverse rotation before aggregating all the updates. Note that in practice, the dimension of $h$ can easily be as high as $d = \\bar { 1 0 ^ { 6 } }$ or more, and it is computationally prohibitive to generate $( \\mathcal { O } ( d ^ { 3 } ) )$ and apply $( \\mathcal { O } ( d ^ { 2 } ) )$ a general rotation matrix. Same as Suresh et al. (2017), we use a type of structured rotation matrix which is the product of a Walsh-Hadamard matrix and a binary diagonal matrix. This reduces the computational complexity of generating and applying the matrix to $\\bar { \\mathcal { O } } ( d )$ and ${ \\mathcal { O } } ( d \\log d )$ , which is negligible compared to the local training within Federated Learning. ",
+        "bbox": [
+            173,
+            535,
+            825,
+            633
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            655,
+            326,
+            670
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We conducted experiments using Federated Learning to train deep neural networks for two different tasks. First, we experiment with the CIFAR-10 image classification task (Krizhevsky, 2009) with convolutional networks and artificially partitioned dataset, and explore properties of our proposed algorithms in detail. Second, we use more realistic scenario for Federated Learning — the public Reddit post data (Google BigQuery), to train a recurrent network for next word prediction. ",
+        "bbox": [
+            174,
+            686,
+            823,
+            756
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The Reddit dataset is particularly useful for simulated Federated Learning experiments, as it comes with natural per-user data partition (by author of the posts). This includes many of the characteristics expected to arise in practical implementation. For example, many users having relatively few data points, and words used by most users are clustered around a specific topic of interest of the particular user. ",
+        "bbox": [
+            174,
+            762,
+            823,
+            833
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In all of our experiments, we employ the Federated Averaging algorithm (McMahan et al., 2017), which significantly decreases the number of rounds of communication required to train a good model. Nevertheless, we expect our techniques will show a similar reduction in communication costs when applied to a synchronous distributed SGD, see for instance Alistarh et al. (2016). For Federated Averaging, on each round we select multiple clients uniformly at random, each of which performs several epochs of SGD with a learning rate of $\\eta$ on their local dataset. For the structured updates, SGD is restricted to only update in the restricted space, that is, only the entries of $\\mathbf { B } _ { t } ^ { i }$ for low-rank updates and the unmasked entries for the random-mask technique. From this updated model we compute the updates for each layer $\\mathbf { H } _ { t } ^ { i }$ . In all cases, we run the experiments with a range of choices of learning rate, and report the best result. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/c86d7a1bc34a8cb47c173e90e8061180181b9ec2d48241acdcc0a6f928b4516c.jpg",
+        "image_caption": [
+            "Figure 1: Structured updates with the CIFAR data for size reduction various modes. Low rank updates in top row, random mask updates in bottom row. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            248,
+            99,
+            746,
+            306
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            383,
+            825,
+            439
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 CONVOLUTIONAL MODELS ON THE CIFAR-10 DATASET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            460,
+            607,
+            476
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section we use the CIFAR-10 dataset to investigate the properties of our proposed methods as part of Federated Averaging algorithm. ",
+        "bbox": [
+            173,
+            488,
+            823,
+            517
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "There are 50 000 training examples in the CIFAR-10 dataset, which we randomly partitioned into 100 clients each containing 500 training examples. The model architecture we used was the allconvolutional model taken from what is described as “Model $\\mathbf { { C } } ^ { \\ast }$ in Springenberg et al. (2014), for a total of over $1 0 ^ { 6 }$ parameters. While this model is not the state-of-the-art, it is sufficient for our needs, as our goal is to evaluate our compression methods, not to achieve the best possible accuracy on this task. ",
+        "bbox": [
+            174,
+            523,
+            825,
+            608
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The model has 9 convolutional layers, first and last of which have significantly fewer parameters than the others. Hence, in this whole section, when we try to reduce the size the individual updates, we only compress the inner 7 layers, each of which with the same parameter3. We denote this by keyword ‘mode’, for all approaches. For low rank updates, ‘mode $= 2 5 \\%$ ’ refers to the rank of the update being set to $1 / 4$ of rank of the full layer transformation, for random mask or sketching, this refers to all but $2 5 \\%$ of the parameters being zeroed out. ",
+        "bbox": [
+            174,
+            614,
+            825,
+            698
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the first experiment, summarized in Figure 1, we compare the two types of structured updates introduced in Section 2 — low rank in the top row and random mask in the bottom row. The main message is that random mask performs significantly better than low rank, as we reduce the size of the updates. In particular, the convergence speed of random mask seems to be essentially unaffected when measured in terms of number of rounds. Consequently, if the goal was to only minimize the upload size, the version with reduced update size is a clear winner, as seen in the right column. ",
+        "bbox": [
+            174,
+            705,
+            825,
+            789
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In Figure 2, we compare the performance of structured and sketched updates, without any quantization. Since in the above, the structured random mask updates performed better, we omit low rank update for clarity from this comparison. We compare this with the performance of the sketched updates, with and without preprocessing the update using random rotation, as described in Section 3, and for two different modes. We denote the randomized Hadamard rotation by ‘HD’, and no rotation by ‘I’. ",
+        "bbox": [
+            174,
+            796,
+            825,
+            878
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/9e7e8cebe5e565d2769a9865c860ded6318bb53db1d96993a9a66b6b72d98263.jpg",
+        "image_caption": [
+            "Figure 2: Comparison of structured random mask updates and sketched updates without quantization on the CIFAR data. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            250,
+            99,
+            745,
+            209
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/b97f7821c5c4e8e3b4c7dcc69bfe26cda7fddcaaa73f847d7fb0af85c0744145.jpg",
+        "image_caption": [
+            "Figure 3: Comparison of sketched updates, combining preprocessing the updates with rotations, quantization and subsampling on the CIFAR data. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            246,
+            280,
+            746,
+            712
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The intuitive expectation is that directly learning the structured random mask updates should be better than learning an unstructured update, which is then sketched to be represented with the same number of parameters. This is because by sketching we throw away some of the information obtained during training. The fact that with sketching the updates, we should converge to a slightly lower accuracy can be theoretically supported, using analogous argument as carefully stated in (Alistarh et al., 2016), since sketching the updates increases the variance directly appearing in convergence analysis. We see this behaviour when using the structured random mask updates, we are able to eventually converge to slightly higher accuracy. However, we also see that with sketching the updates, we are able to attain modest accuracy (e.g. $8 5 \\%$ ) slightly faster. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the last experiment on CIFAR data, we focus on interplay of all three elements introduced in Section 3 — subsampling, quantization and random rotations. Note that combination of all these tools will enable higher compression rate than in the above experiments. Each pair of plots in Figure 3 focuses on particular mode (subsampling), and in each of them we plot performance with different bits used in quantization, with or without the random rotations. What we can see consistently in all plots, is that the random rotation improves the performance. In general, the behaviour of the algorithm is less stable without the rotations, particularly with small number of quantization bits and smaller modes. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            214
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In order to highlight the potential of communication savings, note that by preprocessing with the random rotation, sketching out all but $6 . 2 5 \\%$ elements of the update and using 2 bits for quantization, we get only a minor drop in convergence, while saving factor of 256 in terms of bits needed to represent the updates to individual layers. Finally, if we were interested in minimizing the amount of data uploaded, we can obtain a modest accuracy, say $8 5 \\%$ , while in total communicating less than half of what would be required to upload the original data. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            305
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 LSTM NEXT-WORD PREDICTION ON REDDIT DATA ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            330,
+            573,
+            344
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We constructed the dataset for simulating Federated Learning based on the data containing publicly available posts/comments on Reddit (Google BigQuery), as described by Al-Rfou et al. (2016). Critically for our purposes, each post in the database is keyed by an author, so we can group the data by these keys, making the assumption of one client device per author. Some authors have a very large number of posts, but in each round of FedAvg we process at most 32 000 tokens per user. We omit authors with fewer than 1600 tokens, since there is constant overhead per client in the simulation, and users with little data don’t contribute much to training. This leaves a dataset of 763 430 users, with an average of 24 791 tokens per user. For evaluation, we use a relatively small test set of 75 122 tokens formed from random held-out posts. ",
+        "bbox": [
+            174,
+            359,
+            825,
+            484
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Based on this data, we train a LSTM next word prediction model. The model is trained to predict the next word given the current word and a state vector passed from the previous time step. The model works as follows: word $s _ { t }$ is mapped to an embedding vector $e _ { t } \\in \\mathbb { R } ^ { 9 6 }$ , by looking up the word in a dictionary of 10 017 words (tokens). $e _ { t }$ is then composed with the state emitted by the model in the previous time step $s _ { t 1 } \\in \\mathbb { R } ^ { 2 5 6 }$ to emit a new state vector $s _ { t }$ and an “output embedding” $o _ { t } \\in \\mathbf { R } ^ { 9 6 }$ . The output embedding is scored against the embedding of each item in the vocabulary via inner product, before being normalized via softmax to compute a probability distribution over the vocabulary. Like other standard language models, we treat every input sequence as beginning with an implicit “BOS” (beginning of sequence) token and ending with an implicit “EOS” (end of sequence) token. Unlike standard LSTM language models, our model uses the same learned embedding for both the embedding and softmax layers. This reduces the size of the model by about $40 \\%$ for a small decrease in model quality, an advantageous tradeoff for mobile applications. Another change from many standard LSTM RNN approaches is that we train these models to restrict the word embeddings to have a fixed L2 norm of 1.0, a modification found to improve convergence time. In total the model has 1.35M parameters. ",
+        "bbox": [
+            174,
+            492,
+            825,
+            699
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In order to reduce the size of the update, we sketch all the model variables except some small variables (such as biases) which consume less than $0 . 0 1 \\%$ of memory. We evaluate using AccuracyTop1, the probability that the word to which the model assigns highest probability is correct. We always count it as a mistake if the true next word is not in the dictionary, even if the model predicts ‘unknown’. ",
+        "bbox": [
+            176,
+            707,
+            823,
+            776
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In Figure 4, we run the Federated Averaging algorithm on Reddit data, with various parameters that specify the sketching. In every iteration, we randomly sample 50 users that compute update based on the data available locally, sketch it, and all the updates are averaged. Experiments with sampling 10, 20, and 100 clients in each round provided similar conclusions as the following. ",
+        "bbox": [
+            176,
+            784,
+            823,
+            839
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In all of the plots, we combine the three components for sketching the updates introduced in Section 3. First, we apply a random rotation to preprocess the local update. Further, ‘sketch fraction’ set to either 0.1 or 1, denotes fraction of the elements of the update being subsampled. ",
+        "bbox": [
+            176,
+            847,
+            823,
+            888
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the left column, we plot this against the number of iterations of the algorithm. First, we can see that the effect of preprocessing with the random rotation has significantly positive effect, particularly with small number of quantization bits. It is interesting to see that for all choices of the subsampling ratio, randomized Hadamard transform with quantization into 2 bits does not incur any loss in performance. An important measure to highlight is the number of rounds displayed in the plots is 2000. Since we sample 50 users per round, this experiment would not touch the data of most users even once! This further strengthens the claim that applying Federated Learning in realistic setting is possible without affecting the user experience in any way. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/7c478fbe9950e9655b5cd7577dda68b7b90ea639379e66c20ce989ea66fef5a5.jpg",
+        "image_caption": [
+            "Figure 4: Comparison of sketched updates, training a recurrent model on the Reddit data, randomly sampling 50 clients per round. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            248,
+            102,
+            746,
+            316
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/dbe30e167e6e5114869bc54a27ea60da92be0de1a8a670768d619a9862913202.jpg",
+        "image_caption": [
+            "Figure 5: Effect of the number of clients used in training per round. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            316,
+            381,
+            681,
+            540
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            603,
+            825,
+            688
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In the right column, we plot the same data against the total number of megabytes that would need to be communicated by clients back to the server. From these plots, it is clear that if one needed to primarily minimize this metric, the techniques we propose are extremely efficient. Of course, neither of these objectives is what we would optimize for in a practical application. Nevertheless, given the current lack of experience with issues inherent in large scale deployment of Federated Learning, we believe that these are useful proxies for what will be relevant in a practical application. ",
+        "bbox": [
+            173,
+            694,
+            825,
+            777
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Finally, in Figure 5, we study the effect of number of clients we use in a single round on the convergence. We run the Federated Averaging algorithm for a fixed number of rounds (500 and 2500) with varying number of clients per round, quantize updates to 1 bit, and plot the resulting accuracy. We see that with sufficient number of clients per round, 1024 in this case, we can reduce the fraction of subsampled elements down to $1 \\%$ , with only minor drop in accuracy compared to $1 0 \\%$ . This suggests an important and practical tradeoff in the federated setting: one can select more clients in each round while having each of them communicate less (e.g., more aggressive subsampling), and obtain the same accuracy as using fewer clients, but having each of them communicate more. The former may be preferable when many clients are available, but each has very limited upload bandwidth — which is a setting common in practice. ",
+        "bbox": [
+            173,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            285,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Rami Al-Rfou, Marc Pickett, Javier Snaider, Yun-hsuan Sung, Brian Strope, and Ray Kurzweil. Conversational contextual cues: The case of personalization and history for response ranking. arXiv:1606.00372, 2016. ",
+        "bbox": [
+            176,
+            125,
+            823,
+            151
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dan Alistarh, Jerry Li, Ryota Tomioka, and Milan Vojnovic. QSGD: Randomized quantization for communication-optimal stochastic gradient descent. arXiv:1610.02132, 2016. ",
+        "bbox": [
+            173,
+            159,
+            821,
+            186
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Keith Bonawitz, Vladimir Ivanov, Ben Kreuter, Antonio Marcedone, H. Brendan McMahan, Sarvar Patel, Daniel Ramage, Aaron Segal, and Karn Seth. Practical secure aggregation for privacy preserving machine learning. In ACM Conference on Computer and Communications Security (ACM CCS), 2017. ",
+        "bbox": [
+            176,
+            194,
+            823,
+            234
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Trishul Chilimbi, Yutaka Suzue, Johnson Apacible, and Karthik Kalyanaraman. Project adam: Building an efficient and scalable deep learning training system. In 11th USENIX Symposium on Operating Systems Design and Implementation (OSDI 14), pp. 571–582, 2014. ",
+        "bbox": [
+            174,
+            242,
+            825,
+            281
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey Dean, Greg Corrado, Rajat Monga, Kai Chen, Matthieu Devin, Mark Mao, Andrew Senior, Paul Tucker, Ke Yang, Quoc V Le, et al. Large scale distributed deep networks. In NIPS, pp. 1223–1231, 2012. ",
+        "bbox": [
+            173,
+            290,
+            821,
+            316
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Misha Denil, Babak Shakibi, Laurent Dinh, Nando de Freitas, et al. Predicting parameters in deep learning. In NIPS, pp. 2148–2156, 2013. ",
+        "bbox": [
+            174,
+            324,
+            823,
+            351
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mostafa El Gamal and Lifeng Lai. On randomized distributed coordinate descent with quantized updates. arXiv:1609.05539, 2016. ",
+        "bbox": [
+            173,
+            359,
+            821,
+            386
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Daniel Golovin, D. Sculley, H. Brendan McMahan, and Michael Young. Large-scale learning with less ram via randomization. In ICML, 2013. ",
+        "bbox": [
+            173,
+            393,
+            823,
+            421
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Google BigQuery. Reddit comments dataset. BigQuery, 2016. https://bigquery.cloud.google. com/dataset/fh-bigquery. ",
+        "bbox": [
+            173,
+            429,
+            820,
+            457
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. arXiv preprint arXiv:1510.00149, 2015. ",
+        "bbox": [
+            173,
+            464,
+            821,
+            492
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jakub Konecnˇ y and Peter Richt ´ arik. Randomized distributed mean estimation: Accuracy vs communication. ´ arXiv:1611.07555, 2016. ",
+        "bbox": [
+            174,
+            500,
+            823,
+            526
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jakub Konecnˇ y, H. Brendan McMahan, Daniel Ramage, and Peter Richt ´ arik. Federated optimization: Dis- ´ tributed machine learning for on-device intelligence. arXiv preprint arXiv:1610.02527, 2016. ",
+        "bbox": [
+            174,
+            534,
+            821,
+            561
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, 2009. ",
+        "bbox": [
+            174,
+            569,
+            741,
+            584
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chenxin Ma, Jakub Konecnˇ y, Martin Jaggi, Virginia Smith, Michael I Jordan, Peter Richt ´ arik, and Martin ´ Taka´c. Distributed optimization with arbitrary local solvers. ˇ Optimization Methods & Software, 32(4): 813–848, 2017. ",
+        "bbox": [
+            176,
+            592,
+            823,
+            631
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "H. Brendan McMahan and Daniel Ramage. Federated learning: Collaborative machine learning without centralized training data. https://research.googleblog.com/2017/04/federated-learning-collaborative.html, 2017. ",
+        "bbox": [
+            173,
+            640,
+            823,
+            666
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "H. Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Aguera y Arcas. Communication-efficient learning of deep networks from decentralized data. In Proceedings of the 20th International Conference on Artificial Intelligence and Statistics (AISTATS), 2017. ",
+        "bbox": [
+            176,
+            674,
+            823,
+            714
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "M.G. Rabbat and R.D. Nowak. Quantized incremental algorithms for distributed optimization. IEEE Journal on Selected Areas in Communications, 23(4):798–808, 2005. ",
+        "bbox": [
+            173,
+            722,
+            821,
+            750
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sashank J Reddi, Jakub Konecnˇ y, Peter Richt ´ arik, Barnab ´ as P ´ ocz ´ os, and Alex Smola. AIDE: Fast and commu-´ nication efficient distributed optimization. arXiv:1608.06879, 2016. ",
+        "bbox": [
+            173,
+            757,
+            821,
+            784
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ohad Shamir, Nathan Srebro, and Tong Zhang. Communication-efficient distributed optimization using an approximate Newton-type method. In ICML, pp. 1000–1008, 2014. ",
+        "bbox": [
+            173,
+            791,
+            821,
+            819
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Reza Shokri and Vitaly Shmatikov. Privacy-preserving deep learning. In Proceedings of the 22Nd ACM SIGSAC Conference on Computer and Communications Security, CCS ’15, 2015. ",
+        "bbox": [
+            173,
+            828,
+            823,
+            854
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "speedtest.net. Speedtest market report. http://www.speedtest.net/reports/united-states/, August 2016. ",
+        "bbox": [
+            176,
+            863,
+            823,
+            888
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jost Tobias Springenberg, Alexey Dosovitskiy, Thomas Brox, and Martin Riedmiller. Striving for simplicity: The all convolutional net. arXiv:1412.6806, 2014. ",
+        "bbox": [
+            176,
+            897,
+            823,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ananda Theertha Suresh, Felix X. Yu, Sanjiv Kumar, and H. Brendan McMahan. Distributed mean estimation with limited communication. In Proceedings of the 34th International Conference on Machine Learning, pp. 3329–3337, 2017. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            142
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David P. Woodruff. Sketching as a tool for numerical linear algebra. Foundations and Trends in Theoretical Computer Science, 10(12):1–157, 2014. ISSN 1551-305X. doi: 10.1561/0400000060. ",
+        "bbox": [
+            173,
+            151,
+            823,
+            178
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yuchen Zhang and Xiao Lin. DiSCO: Distributed optimization for self-concordant empirical loss. In ICML, pp. 362–370, 2015. ",
+        "bbox": [
+            174,
+            188,
+            823,
+            213
+        ],
+        "page_idx": 9
+    }
+]

parse/train/B1gqipNYwH/B1gqipNYwH.md

@@ -0,0 +1,373 @@
+# OPTION DISCOVERY USING DEEP SKILL CHAINING
+
+# Akhil Bagaria
+
+# George Konidaris
+
+Department of Computer Science Brown University   
+Providence, RI, USA   
+akhil bagaria@brown.edu   
+Department of Computer Science   
+Brown University   
+Providence, RI, USA   
+gdk@brown.edu
+
+# ABSTRACT
+
+Autonomously discovering temporally extended actions, or skills, is a longstanding goal of hierarchical reinforcement learning. We propose a new algorithm that combines skill chaining with deep neural networks to autonomously discover skills in high-dimensional, continuous domains. The resulting algorithm, deep skill chaining, constructs skills with the property that executing one enables the agent to execute another. We demonstrate that deep skill chaining significantly outperforms both non-hierarchical agents and other state-of-the-art skill discovery techniques in challenging continuous control tasks.1 2
+
+# 1 INTRODUCTION
+
+Hierarchical reinforcement learning (Barto & Mahadevan, 2003) is a promising approach for solving long-horizon sequential decision making problems. Hierarchical methods lower the decision making burden on the agent through the use of problem specific action abstractions (Konidaris, 2019). While the use of temporally extended actions, or options (Sutton et al., 1999), has been shown to accelerate learning (McGovern & Sutton, 1998), there remains the question of skill discovery: how can agents autonomously construct useful skills via interaction with the environment? While a large body of work has sought to answer this question in small discrete domains, skill discovery in high-dimensional continuous spaces remains an open problem.
+
+An early approach to skill discovery in continuous-state environments was skill chaining (Konidaris & Barto, 2009b), where an agent constructs a sequence of options that target a salient event in the MDP (for example, the goal state). The skills are constructed so that successful execution of each option in the chain allows the agent to execute another option, which brings it closer still to its eventual goal. While skill chaining was capable of discovering skills in continuous state spaces, it could only be applied to relatively low-dimensional state-spaces with discrete actions.
+
+We introduce a new algorithm that combines the core insights of skill chaining with recent advances in using non-linear function approximation in reinforcement learning. The new algorithm, deep skill chaining, scales to high-dimensional problems with continuous state and action spaces. Through a series of experiments on five challenging domains in the MuJoCo physics simulator (Todorov et al., 2012), we show that deep skill chaining can solve tasks that otherwise cannot be solved by nonhierarchical agents in a reasonable amount of time. Furthermore, the new algorithm outperforms state-of-the-art deep skill discovery algorithms (Bacon et al., 2017; Levy et al., 2019) in these tasks.
+
+# 2 BACKGROUND AND RELATED WORK
+
+Sequential decision making problems can be formalized as Markov Decision Processes (MDPs). We consider goal-oriented episodic MDPs, where $S$ denotes the state space, $A$ is the action space, $R$ is the reward function, $\tau$ is the transition function, $\gamma$ is the discount factor and $g \in S$ is the terminating goal state (Sutton & Barto, 2018). Unlike goal-conditioned algorithms (Sutton et al., 2011; Schaul et al., 2015), we do not require that $g$ be known; instead we assume access to an indicator function $\mathbb { 1 } _ { g } : s \in S  \{ 0 , 1 \}$ which the agent can query to determine if it has reached the MDP’s goal.
+
+One way to learn a policy in an MDP is to first learn an action-value function. The action-value function $Q ^ { \pi } ( s _ { t } , a _ { t } )$ is defined as the expected sum of discounted future rewards if the agent takes action $a _ { t }$ from $s _ { t }$ and then follows policy $\pi$ thereafter: $\begin{array} { r } { Q ^ { \pi } ( s _ { t } , a _ { t } ) = \mathbb { E } _ { \pi } [ r _ { t } + \gamma \operatorname* { m a x } _ { a _ { t + 1 } } \bar { Q } ^ { \pi } ( s _ { t + 1 } , a _ { t + 1 } ) ] } \end{array}$ .
+
+Q-learning (Watkins & Dayan, 1992) is a commonly used off-policy algorithm that uses the actionvalue function for control through a greedy policy $\pi ( s _ { t } ) = \arg \operatorname* { m a x } _ { a _ { t } } Q ( s _ { t } , a _ { t } )$ . Inspired by recent success in scaling Q-learning to high-dimensional spaces (Mnih et al., 2015; Van Hasselt et al., 2016; Lillicrap et al., 2015; Tesauro, 1994), we learn the action-value function $Q _ { \phi } ^ { \pi } ( s _ { t } , a _ { t } )$ using non-linear function approximators parameterized by $\phi$ , by minimizing the loss $L ( \phi ) = \mathbb { E } _ { \pi } [ ( Q _ { \phi } ( s _ { t } , a _ { t } ) - y _ { t } ) ^ { 2 } ]$ where the Q-learning target $y _ { t }$ is given by the following equation (Van Hasselt et al., 2016):
+
+$$
+y _ { t } = r _ { t } + \gamma Q _ { \phi ^ { \prime } } \bigl ( s _ { t + 1 } , \underset { a _ { t + 1 } } { \arg \operatorname* { m a x } } Q _ { \phi } \bigl ( s _ { t + 1 } , a _ { t + 1 } \bigr ) \bigr ) .
+$$
+
+Deep Q-Learning (DQN) (Mnih et al., 2015) casts minimizing $L ( \phi )$ as a standard regression problem by using target networks (parameterized by $\phi ^ { \prime }$ ) and experience replay (Lin, 1993).
+
+# 2.1 THE OPTIONS FRAMEWORK
+
+The options framework (Sutton et al., 1999) models skills as options. An option $o$ consists of three components: (a) its initiation condition, $\mathcal { T } _ { o } ( s )$ , which determines whether $o$ can be executed in state $s$ , (b) its termination condition, $\beta _ { o } ( s )$ , which determines whether option execution must terminate in state $s$ and (c) its closed-loop control policy, $\pi _ { o } ( s )$ , which maps state $s$ to a low level action $a \in A$ . Augmenting the set of available actions with options results in a Semi-Markov Decision Process (SMDP) (Sutton et al., 1999) where the next state depends on the current state, action and time.
+
+# 2.2 SKILL DISCOVERY ALGORITHMS
+
+Skill discovery has been studied extensively in small discrete domains (McGovern & Sutton, 1998; S¸ ims¸ek & Barto, 2004; S¸ ims¸ek et al., 2005; Bakker & Schmidhuber, 2004; Schmidhuber, 1991; Pickett & Barto, 2002; Dietterich, 2000). Recently however, there has been a significant body of work aimed at discovering skills in continuous spaces.
+
+Option-critic methods: Option-Critic (Bacon et al., 2017) uses an end-to-end gradient based algorithm to learn options in high-dimensional continuous spaces. Option-Critic was a substantial step forward in skill discovery and led to a family of related methods (Klissarov et al., 2017; Tiwari & Thomas, 2019; Riemer et al., 2018; Liu et al., 2017; Jain et al., 2018). Proximal Policy Option Critic (PPOC) (Klissarov et al., 2017) extends Option-Critic to continuous action spaces and is the version of Option-Critic that we compare against in this paper. Our method bypasses two fundamental shortcomings of the Option-Critic framework: (a) unlike Option-Critic, we explicitly learn initiation sets of options and thus do not assume that all options are executable from everywhere, and (b) we do not treat the number of skills required to solve a task as a fixed and costly hyperparameter. Instead, our algorithm flexibly discovers as many skills as it needs to solve the given problem.
+
+Feudal methods: An alternative to the options framework is Feudal RL (Dayan & Hinton, 1993), which creates a hierarchy in which managers learn to assign subgoals to workers; workers take a subgoal state as input and learn to reach it. Feudal Networks (FuN) (Vezhnevets et al., 2017) used neural networks to scale the Feudal-RL framework to high-dimensional continuous spaces; it was extended and outperformed by HIRO (Nachum et al., 2018) in a series of control tasks in the MuJoCo simulator. More recently, Hierarchical Actor-Critic (HAC) (Levy et al., 2019) outperformed HIRO in a similar suite of continuous control problems. While HIRO relies on having a dense “distanceto-goal” based reward function to train both levels of their feudal hierarchy, HAC’s use of Hindsight Experience Replay (HER) (Andrychowicz et al., 2017) allows it to work in the more general sparsereward setting. Given its strong performance in continuous control problems and its ability to learn effectively in sparse-reward settings, we compare against HAC as a representative feudal method.
+
+Learning backward from the goal: The idea of sequencing locally applicable controllers is well established in robotics and control theory in the form of pre-image backchaining (Kaelbling & LozanoPerez, 2017) and LQR-Trees (Tedrake, 2009). Such methods either require individually engineered ´ control loops or a model of the system dynamics. Our work fits in the model-free RL setting and thus requires neither. More recently, reverse curriculum learning (Florensa et al., 2017) also learns backward from the goal. However, they define a curriculum of start states to learn a single policy, rather than learning skills. Relay Networks (Kumar et al., 2018) segment the value function backward from the goal using a thresholding scheme, which makes their method reliant on the accurate estimation of the value function. By contrast, our algorithm is agnostic to errors in value estimation, which are unavoidable when using function approximation in high-dimensional spaces.
+
+Planning with learned skills: Options have been shown to empirically speed up planning in several domains (Silver & Ciosek, 2012; Jinnai et al., 2019; James et al., 2018; Francis & Ram, 1993; Konidaris, 2016; Sharma et al., 2019). However, Konidaris et al. (2018) show that for resulting plans to be provably feasible, skills must be executable sequentially. While they assume that such skills are given, we show that they can be autonomously discovered in high-dimensional spaces.
+
+# 3 DEEP SKILL CHAINING
+
+Deep skill chaining (DSC) is based on the intuition that it is easier to solve a long-horizon task from states in the local neighborhood of the goal. This intuition informs the first step of the algorithm: create an option that initiates near the goal and reliably takes the agent to the goal. Once such an option is learned, we create another option whose goal is to take the agent to a state from which it can successfully execute the first option. Skills are chained backward in this fashion until the start state of the MDP lies inside the initiation set of some option. The inductive bias of creating sequentially executable skills guarantees that as long as the agent successfully executes each skill in its chain, it will solve the original task. More formally, skill chaining amounts to learning options such that the termination condition $\beta _ { o _ { i } } ( s _ { t } )$ of an option $o _ { i }$ is the initiation condition $\mathcal { T } _ { o _ { i - 1 } } ( s _ { t } )$ of the option that precedes it in its chain.
+
+Our algorithm proceeds as follows: at time $t$ , the policy over options $\pi _ { \mathcal { O } } : s _ { t } \in S  o \in \mathcal { O }$ determines which option to execute (Section 3.2). Control is then handed over to the selected option $o _ { i }$ ’s internal policy $\pi _ { o _ { i } } : s \in S \to a _ { t } \in \mathbb { R } ^ { | A | }$ . $\pi _ { o _ { i } }$ outputs joint torques until it either reaches its goal $( \beta _ { o _ { i } } : = \mathbb { Z } _ { o _ { i - 1 } }$ ) or times out at its predetermined budget $T$ (Section 3.1). At this point, $\pi _ { \mathcal { O } }$ chooses another option to execute. If at any point the agent reaches the goal state of the MDP or the initiation condition of a previously learned option, it creates a new option to target such a salient event. The machinery for learning the initiation condition of this new option is described in Section 3.3. We now detail the components of our architecture and how they are learned. Readers may also refer to Figures $4 \& 7$ and the pseudo-code in Appendix A.5 to gain greater intuition about our algorithm.
+
+# 3.1 INTRA-OPTION POLICY
+
+Each option $o$ maintains its own policy $\pi _ { o } : s \to a _ { t } \in \mathbb { R } ^ { | A | }$ , which is parameterized by its own neural networks $\theta _ { o }$ . To train $\pi _ { o } ( s ; \theta _ { o } )$ , we must define $o$ ’s internal reward function. In sparse reward problems, $o$ is given a subgoal reward when it triggers $\beta _ { o }$ ; otherwise it is given a step penalty. In the dense reward setting, we can compute the distance to the parent option’s initiation set classifier and use that to define $o$ ’s internal reward function. We can now treat learning the intra-option policy $( \pi _ { o } )$ as a standard RL problem and use an off-the-shelf algorithm to learn this policy. Since in this work we solve tasks with continuous action spaces, we use Deep Deterministic Policy Gradient (DDPG) (Lillicrap et al., 2015) to learn option policies over real-valued actions.
+
+# 3.2 POLICY OVER OPTIONS
+
+Initially, the policy over options $\left( \pi _ { \mathcal { O } } \right)$ only possesses one option that operates over a single time step $T = 1$ ). We call this option the global option $( o _ { G } )$ since its initiation condition is true everywhere in the state space and its termination condition is true only at the goal state of the MDP (i.e, $\mathcal { T } _ { o _ { G } } ( s ) =$ $1 \forall s$ and $\beta _ { o _ { G } } = 1 _ { g }$ ). Using $o _ { G } , \pi _ { \mathcal { O } }$ can select primitive actions. At first the agent continually calls upon $o _ { G }$ , which uses its internal option policy $\pi _ { o _ { G } }$ to output exactly one primitive action. Once $o _ { G }$ triggers the MDP’s goal state $N$ times, DSC creates its first temporally extended option, the goal option $( o _ { g } )$ , whose termination condition is also set to be the goal state of the MDP, i.e, $\beta _ { o _ { g } } = \mathbb { 1 } _ { g }$ .
+
+As the agent discovers new skills, it adds them to its option repertoire and relies on $\pi _ { \mathcal { O } }$ to determine which option (including $o _ { G }$ ) it must execute at each state. Unlike $o _ { G }$ , learned options will be temporally extended, i.e, they will operate over $T > 1$ time steps. If in state $s _ { t }$ the agent chooses to execute option $o _ { i }$ , then $o _ { i }$ will execute its own closed-loop control policy (for $\tau$ steps) until its termination condition is met $( \tau < T )$ ) or it has timed out at $\tau = T$ time steps. At this point, control is handed back to $\pi _ { \mathcal { O } }$ , which must now choose a new option at state $s _ { t + \tau }$ .
+
+Option selection: To select an option in state $s _ { t } , \pi _ { \mathcal { O } }$ first constructs a set of admissible options given by Equation 2. $\pi _ { \mathcal { O } }$ then chooses the admissible option that maximizes its option-value function, as shown in Equation 3. Since the agent must choose from a discrete set of options at any time, we learn its option-value function using Deep Q-learning (DQN) (Mnih et al., 2015).
+
+$$
+\begin{array} { c } { { \mathcal { O } ^ { \prime } ( s _ { t } ) = \{ o _ { i } | \mathcal { Z } _ { o _ { i } } ( s _ { t } ) = 1 \cap \beta _ { o _ { i } } ( s _ { t } ) = 0 , \forall o _ { i } \in \mathcal { O } \} } } \\ { { o _ { t } = \arg \operatorname* { m a x } Q _ { \phi } ( s _ { t } , o _ { i } ) . } } \\ { { o _ { i } \epsilon \mathcal { O } ^ { \prime } ( s _ { t } ) } } \end{array}
+$$
+
+Learning the option-value function: Given an SMDP transition $( s _ { t } , o _ { t } , r _ { t : t + \tau } , s _ { t + \tau } )$ , we update the value of taking option $o _ { t }$ in state $s _ { t }$ according to SMDP Q-learning update (Bradtke $\&$ Duff, 1995). Since the agent learns Q-values for different state-option pairs, it may choose to ignore learned options in favor of primitive actions in certain parts of the state-space (in the interest of maximizing its expected future sum of discounted rewards). The Q-value target for learning the weights $\phi$ of the DQN is given by:
+
+$$
+y _ { t } = \sum _ { t ^ { \prime } = t } ^ { \tau } \gamma ^ { t ^ { \prime } - t } r _ { t ^ { \prime } } + \gamma ^ { \tau - t } Q _ { \phi ^ { \prime } } \big ( s _ { t + \tau } , \ \underset { o ^ { \prime } \epsilon \mathcal O ^ { \prime } ( s _ { t + \tau } ) } { \arg \operatorname* { m a x } } \ Q _ { \phi } \big ( s _ { t + \tau } , o ^ { \prime } \big ) \big ) .
+$$
+
+Adding new options to the policy over options: Equations 2, 3 and 4 show how we can learn the option-value function and use it for selecting options. However, we must still incrementally add new skills to the network during the agent’s lifetime. After the agent has learned a new option $o$ ’s initiation set classifier $\mathcal { T } _ { o }$ (we will discuss how this happens in Section 3.3), it performs the following steps before it can add $o$ to its option repertoire:
+
+• To initialize $o$ ’s internal policy $\pi _ { o }$ , the parameters of its DDPG $\left( \theta _ { o } \right)$ are set to the parameters of the global agent’s DDPG $( \theta _ { o _ { G } } )$ . Subsequently, their neural networks are trained independently. This provides a good starting point for optimizing $\pi _ { o }$ , while allowing it to learn sub-problem specific abstractions.   
+• To begin predicting Q-values for $o$ , we add a new output node to final layer of the DQN parameterizing $\pi _ { \mathcal { O } }$ .   
+• We must assign appropriate initial values to $Q _ { \phi } ( s , o )$ . We follow Konidaris & Barto (2009b) and collect all the transitions that triggered $\beta _ { o }$ and use the max over these Q-values to optimistically initialize the new output node of our DQN.3 This is done by setting the bias of this new node, which ensures that the $\mathrm { Q }$ -value predictions corresponding to the other options remain unchanged.
+
+# 3.3 INITIATION SET CLASSIFIER
+
+Central to the idea of learning skills is the ability to learn the set of states from which they can be executed. First, we must learn the initiation set classifier for $o _ { g }$ , the option used to trigger the MDP’s goal state. While acting in the environment, the agent’s global DDPG will trigger the goal state $N$ times (also referred to as the gestation period of the option by Konidaris & Barto (2009b) and Niekum & Barto (2011)). We collect these $N$ successful trajectories, segment the last $K$ states from each trajectory and learn a one-class classifier around the segmented states. Once initialized, it may be necessary to refine the option’s initiation set based on its policy. We do so by executing the option and collecting data to train a two-class classifier. States from which option execution was successful are labeled as positive examples. States from which option execution timed out are labeled as negative examples. We continue this process of refining the option’s initiation set classifier for a fixed number of episodes, which we call the initiation period of the option.
+
+At the end of the initiation period, we fix the option’s initiation set classifier and add it to the list of salient events in the MDP. We then construct a new option whose termination condition is the initiation classifier of the option we just learned. We continue adding to our chain of options in this fashion until a learned initiation set classifier contains the start state of the MDP.
+
+# 3.4 GENERALIZING TO SKILL TREES
+
+Our discussion so far has been focused on learning skill chains that extend from the goal to the start state of the MDP. However, such a chain is not sufficient if the agent has multiple start states or if we want the agent to learn multiple ways of solving the same problem. To permit such behavior, our algorithm can be used to learn skills that organize more generally in the form of trees (Konidaris & Barto, 2009b; Konidaris et al., 2012). This generalization requires some additional care while learning initiation set classifiers, the details of which can be found in Section A.1 of the Appendix. To demonstrate our ability to construct such skill trees (and their usefulness), we consider a maze navigation task, E-Maze, with distinct start states in Section 4.
+
+# 3.5 OPTIMALITY OF DISCOVERED SOLUTIONS
+
+Each option $o$ ’s internal policy $\pi _ { o }$ is is given a subgoal reward only when it triggers its termination condition $\beta _ { o }$ . As a result, $\pi _ { o }$ is trained to find the optimal trajectory for entering its own goal region. Naively executing learned skills would thus yield a recursively optimal solution to the MDP (Barto & Mahadevan, 2003). However, since the policy over options $\pi _ { \mathcal { O } }$ does not see subgoal rewards and is trained using extrinsic rewards only, it can combine learned skills and primitive actions to discover a flat optimal solution $\pi ^ { * }$ to the MDP (Barto & Mahadevan, 2003). Indeed, our algorithm allows $\pi _ { \mathcal { O } }$ to employ discovered skills to quickly and reliably find feasible paths to the goal, which over time can be refined into optimal solutions. It is worth noting that our ability to recover $\pi ^ { * }$ in the limit is in contrast to feudal methods such as HAC (Levy et al., 2019) in which higher levels of the hierarchy are rewarded for choosing feasible subgoals, not optimal ones.
+
+To summarize, our algorithm proceeds as follows: (1) Collect trajectories that trigger new option $O _ { k }$ ’s termination condition $\beta _ { o _ { k } }$ . (2) Train $o _ { k }$ ’s option policy $\pi _ { o _ { k } }$ . (3) Learn $o _ { k }$ ’s initiation set classifier $\mathcal { T } _ { o _ { k } }$ . (4) Add $o _ { k }$ to the agent’s option repertoire. (5) Create a new option $O k { + 1 }$ such that $\beta _ { o _ { k + 1 } } = \mathcal { T } _ { o _ { k } }$ . (6) Train policy over options $\pi _ { \mathcal { O } }$ . Steps 1, 3, 4 and 5 continue until the MDP’s start state is inside some option’s initiation set. Continue steps 2 and 6 indefinitely.
+
+# 4 EXPERIMENTS
+
+We test our algorithm in five tasks that exhibit a strong hierarchical structure: (1) Point-Maze (Duan et al., 2016), (2) Four Rooms with Lock and Key, (3) Reacher (Brockman et al., 2016), (4) Point E-Maze and (5) Ant-Maze (Duan et al., 2016; Brockman et al., 2016). Since tasks 1, 3 and 5 appear frequently in the literature, details of their setup can be found in Appendix A.3.
+
+Four Rooms with Lock and Key: In this task, a point agent (Duan et al., 2016) is placed in the Four Rooms environment (Sutton et al., 1999). It must pick up the key (blue sphere in the top-right room in Figure 1(c), row 2) and then navigate to the lock (red sphere in the top-left room). The agent’s state space consists of its position, orientation, linear velocity, rotational velocity and a has key indicator variable. If it reaches the lock with the key in its possession, its episode terminates with a sparse reward of 0; otherwise it gets a step penalty of $- 1$ . If we wish to autonomously discover the importance of the key, (i.e, without any corresponding extrinsic rewards) a distance-based dense reward such as that used in related work (Nachum et al., 2018) would be infeasible.
+
+Point E-Maze: This task extends the benchmark U-shaped Point-Maze task (Duan et al., 2016) so that the agent has two possible start locations - on the top and bottom rungs of the E-shaped maze respectively. We include this task to demonstrate our algorithm’s ability to construct skill trees.
+
+# 4.1 COMPARATIVE ANALYSES
+
+We compared the performance of our algorithm to DDPG, Option-Critic and Hierarchical ActorCritic (HAC), in the conditions most similar to those in which they were originally evaluated. For instance, in the Ant-Maze task we compare against Option-Critic under a dense-reward formulation of the problem while comparing to HAC under a sparse-reward version of the same task. As a result, we show the learning curves comparing against them on different plots (columns (a) and (b) in Figure 1 respectively) to emphasize the difference between the algorithms, the settings in which they are applicable, and the way they are evaluated.
+
+![](images/697848785d9ab3077051b3a746a3382783f1c3bab8db438fbfb212c44bb9afcc.jpg)  
+Figure 1: (a) Learning curves comparing deep skill chaining (DSC), a flat agent (DDPG) and OptionCritic. (b) Comparison with Hierarchical Actor Critic (HAC). (c) the continuous control tasks corresponding to the learning curves in (a) and (b). Solid lines represent median reward per episode, with error bands denoting one standard deviation. Our algorithm remains the same between (a) and (b). All curves are averaged over 20 runs, except for Ant Maze which was averaged over 5 runs.
+
+![](images/5abee1d28fc428024ed73b0642786995a25bd95477a49cacef860deb0bdb465a.jpg)  
+Figure 2: Initiation sets of options learned in the Lock and Key task. Blue sphere in top-right room represents the key, red sphere in top-left room represents the lock. Red regions represent states inside the initiation classifier of learned skills, whereas blue/gray regions represent states outside of it. Each column represents an option - the top row corresponding to the initiation set when has key is false and the bottom row corresponding to the initiation set when has key is true.
+
+Comparison with DDPG and Option-Critic: Figure 1(a) shows the results of comparing our proposed algorithm (DSC) with a flat RL agent (DDPG) and the version of Option-Critic designed for continuous action spaces (PPOC).4 Deep skill chaining comfortably outperforms both baselines. Both DSC and DDPG use the same exploration strategy in which $a _ { t } \doteq \pi _ { \theta } ( s _ { t } ) + \eta _ { t }$ where $\eta _ { t } \sim N ( 0 , \epsilon _ { t } )$ . Option-Critic, on the other hand, learns a stochastic policy $\pi _ { \boldsymbol { \theta } } \big ( a _ { t } | \boldsymbol { s } _ { t } \big )$ and thus has baked-in exploration (Sutton & Barto, 2018, Ch. 13), precluding the need for additive noise during action selection. We hypothesize that this difference in exploration strategies is the reason OptionCritic initially performs better than both DDPG and DSC in the Reacher and Point E-Maze tasks.
+
+Comparison with Hierarchical Actor-Critic: We compare our algorithm to Hierarchical ActorCritic (HAC) (Levy et al., 2019), which has recently outperformed other hierarchical reinforcement learning methods (Nachum et al., 2018; Vezhnevets et al., 2017) on a wide variety of tasks. $^ { 5 } \mathrm { ~ \bf ~ A ~ }$ noteworthy property of the HAC agent is that it may prematurely terminate its training episodes to prevent flooding its replay buffer with uninformative transitions. The length of each training episode in DSC however, is fixed and determined by the test environment. Unless the agent reaches the goal state, its episode lasts for the entirety of its episodic budget (e.g, this would be 1000 timesteps in the Point-Maze environment). Thus, to compare the two algorithms, we perform periodic test rollouts wherein all networks are frozen and both algorithms have the same time budget to solve the given task. Furthermore, since both DSC and HAC learn deterministic policies, we set $\epsilon _ { t } = 0$ during these test rollouts. When comparing to HAC, we perform 1 test rollout after each training episode in all tasks except for Ant-Maze, where we average performance over 5 test rollouts every 10 episodes.
+
+Figure 1(b) shows that DSC outperforms HAC in all environments except for Four Rooms with a Lock and Key, where their performance is similar, even though DSC does not use Hindsight Experience Replay (Andrychowicz et al., 2017) to deal with the sparse reward nature of this task.
+
+# 4.2 INTERPRETING LEARNED SKILLS
+
+Figure 2 visualizes the initiation set classifiers of options discovered by DSC in Four Rooms with a Lock and Key. Despite not getting any extrinsic reward for picking up the key, DSC discovers the following skill chain: the options shown in Figure 2 columns (c) and (d) bring the agent to the room with the key. The option shown in column (b) then picks up the key (top row) and then takes the agent to the room with the lock (bottom row). Finally, the option in column (a) solves the overall problem by navigating to the lock with the key. Similar visualizations of learned initiation set classifiers in the E-Maze task can be found in the Figure 6 in the Appendix.
+
+![](images/408f4247f050f9527a062e4cf18e13ce9058efa8964d789d24987a6b3b65a070.jpg)  
+Figure 3: Solution trajectories found by deep skill chaining. Sub-figure (d) shows two trajectories corresponding to the two possible initial locations in this task. Black points denote states in which $\pi _ { \mathcal { O } }$ chose primitive actions, other colors denote temporally extended option executions.
+
+Figure 3 shows that DSC is able to learn options that induce simple, efficient policies along different segments of the state-space. Furthermore, it illustrates that in some states, the policy over options prefers primitive actions (shown in black) over learned skills. This suggests that DSC is robust to situations in which it constructs poor options or is unable to learn a good option policy in certain portions of the state-space. In particular, Figure 3 (d) shows how DSC constructs a skill tree to solve a problem with two distinct start states. It learns a common option near the goal (shown in blue), which then branches off into two different chains leading to its two different start states respectively.
+
+# 5 DISCUSSION AND CONCLUSION
+
+Deep skill chaining breaks complex long-horizon problems into a series of sub-problems and learns policies that solve those sub-problems. By doing so, it provides a significant performance boost when compared to a flat learning agent in all of the tasks considered in Section 4.
+
+We show superior performance when compared to Option-Critic, the leading framework for option discovery in continuous domains. A significant drawback of Option-Critic is that it assumes that all options are executable from everywhere in the state-space. By contrast, deep skill chaining explicitly learns initiation set classifiers. As a result, learned skills specialize in different regions of the statespace and do not have to bear the burden of learning representations for states that lie far outside of their initiation region. Furthermore, each option in the Option-Critic architecture leverages the same state-abstraction to learn option-specific value functions and policies, while deep skill chaining permits each skill to construct its own skill-specific state-abstraction (Konidaris & Barto, 2009a). An advantage of using Option-Critic over DSC is that it is not confined to goal-oriented tasks and can work in tasks which require continually maximizing non-sparse rewards.
+
+Section 4 also shows that deep skill chaining outperforms HAC in four out of five domains, while achieving comparable performance in one. We note that even though HAC was designed to work in the multi-goal setting, we test it here in the more constrained single-goal setting. Consequently, we argue that in problems which permit a stationary set of target events (like the ones considered here), deep skill chaining provides a favorable alternative to HAC. Furthermore, HAC depends on Hindsight Experience Replay (HER) to train the different layers of their hierarchy. Deep skill chaining shows the benefits of using hierarchies even in the absence of such data augmentation techniques but including them should yield additional performance benefits in sparse-reward tasks.
+
+A drawback of deep skill chaining is that, because it builds skills backward from the goal, its performance in large state-spaces is dependent on a good exploration algorithm. We used the naive exploration strategy of adding Gaussian noise to chosen actions (Lillicrap et al., 2015; Fujimoto et al., 2018) since the exploration question is orthogonal to the ideas presented here. The lack of a sophisticated exploration algorithm also explains the higher variance in performance in the PointMaze task in Figure 1. Combining effective exploration (Machado et al., 2018; Jinnai et al., 2020) with DSC’s high reliability of triggering target events is a promising avenue for future work.
+
+We presented a new skill discovery algorithm that can solve high-dimensional goal-oriented tasks far more reliably than flat RL agents and other popular hierarchical methods. To our knowledge,
+
+DSC is the first deep option discovery algorithm that does not treat the number of options as a fixed and costly hyperparameter. Furthermore, where other deep option discovery techniques have struggled to show consistent improvements over baseline flat agents in the single task setting (Zhang & Whiteson, 2019; Smith et al., 2018; Harb et al., 2018; Klissarov et al., 2017), we unequivocally show the necessity for hierarchies for solving challenging problems.
+
+# 6 ACKNOWLEDGEMENTS
+
+We thank Andrew Levy, Nakul Gopalan, Sam Lobel, Theresa Barton and other members of the Brown bigAI group for their inputs. This research was supported in part by DARPA under agreement number W911NF1820268, AFOSR Young Investigator Grant agreement number FA9550-17- 1-0124 and the ONR under the PERISCOPE MURI Contract N00014-17-1-2699. The U.S. Government is authorized to reproduce and distribute reprints for Governmental purposes notwithstanding any copyright notation thereon. The content is solely the responsibility of the authors and does not necessarily represent the official views of DARPA, the ONR, or the AFOSR.
+
+# REFERENCES
+
+Marcin Andrychowicz, Filip Wolski, Alex Ray, Jonas Schneider, Rachel Fong, Peter Welinder, Bob McGrew, Josh Tobin, OpenAI Pieter Abbeel, and Wojciech Zaremba. Hindsight experience replay. In Advances in Neural Information Processing Systems, pp. 5048–5058, 2017.   
+Pierre-Luc Bacon, Jean Harb, and Doina Precup. The option-critic architecture. In Thirty-First AAAI Conference on Artificial Intelligence, 2017.   
+Bram Bakker and Jurgen Schmidhuber. Hierarchical reinforcement learning with subpolicies spe- ¨ cializing for learned subgoals. In Neural Networks and Computational Intelligence, pp. 125–130. Citeseer, 2004.   
+Andrew G Barto and Sridhar Mahadevan. Recent advances in hierarchical reinforcement learning. Discrete event dynamic systems, 13(1-2):41–77, 2003.   
+Marc Bellemare, Sriram Srinivasan, Georg Ostrovski, Tom Schaul, David Saxton, and Remi Munos. Unifying count-based exploration and intrinsic motivation. In Advances in Neural Information Processing Systems, pp. 1471–1479, 2016.   
+Steven J Bradtke and Michael O Duff. Reinforcement learning methods for continuous-time markov decision problems. In Advances in neural information processing systems, pp. 393–400, 1995.   
+Ronen I Brafman and Moshe Tennenholtz. R-Max - a general polynomial time algorithm for nearoptimal reinforcement learning. Journal of Machine Learning Research, 3(Oct):213–231, 2002.   
+Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym. arXiv preprint arXiv:1606.01540, 2016.   
+Yuri Burda, Harrison Edwards, Amos Storkey, and Oleg Klimov. Exploration by random network distillation. In International Conference on Learning Representations, 2019. URL https: //openreview.net/forum?id ${ . } = { }$ H1lJJnR5Ym.   
+Peter Dayan and Geoffrey E Hinton. Feudal reinforcement learning. In Advances in neural information processing systems, pp. 271–278, 1993.   
+Thomas G Dietterich. Hierarchical reinforcement learning with the maxq value function decomposition. Journal of Artificial Intelligence Research, 13:227–303, 2000.   
+Yan Duan, Xi Chen, Rein Houthooft, John Schulman, and Pieter Abbeel. Benchmarking deep reinforcement learning for continuous control. In International Conference on Machine Learning, pp. 1329–1338, 2016.   
+Carlos Florensa, David Held, Markus Wulfmeier, Michael Zhang, and Pieter Abbeel. Reverse curriculum generation for reinforcement learning. In Conference on Robot Learning, pp. 482–495, 2017.
+
+Anthony G Francis and Ashwin Ram. The utility problem in case-based reasoning. In Case-Based Reasoning: Papers from the 1993 Workshop, pp. 160–161, 1993.
+
+Scott Fujimoto, Herke Hoof, and David Meger. Addressing function approximation error in actorcritic methods. In International Conference on Machine Learning, pp. 1582–1591, 2018.
+
+Jean Harb, Pierre-Luc Bacon, Martin Klissarov, and Doina Precup. When waiting is not an option: Learning options with a deliberation cost. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018.
+
+Arushi Jain, Khimya Khetarpal, and Doina Precup. Safe option-critic: Learning safety in the optioncritic architecture. CoRR, abs/1807.08060, 2018. URL http://arxiv.org/abs/1807. 08060.
+
+Steven James, Benjamin Rosman, and George Konidaris. Learning to plan with portable symbols. the ICML/IJCAI/AAMAS 2018 Workshop on Planning and Learning, 2018.
+
+Yuu Jinnai, David Abel, David Hershkowitz, Michael Littman, and George Konidaris. Finding options that minimize planning time. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pp. 3120–3129, Long Beach, California, USA, 09–15 Jun 2019. PMLR. URL http://proceedings.mlr.press/v97/jinnai19a.html.
+
+Yuu Jinnai, Jee Won Park, Marlos C. Machado, and George Konidaris. Exploration in reinforcement learning with deep covering options. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id ${ . } = { }$ SkeIyaVtwB.
+
+Leslie Pack Kaelbling and Tomas Lozano-P ´ erez. Pre-image backchaining in belief space for mobile ´ manipulation. In Robotics Research, pp. 383–400. Springer, 2017.
+
+Martin Klissarov, Pierre-Luc Bacon, Jean Harb, and Doina Precup. Learnings options end-to-end for continuous action tasks. Hierarchical Reinforcement Learning Workshop (NeurIPS), 2017.
+
+George Konidaris. Constructing abstraction hierarchies using a skill-symbol loop. In IJCAI: proceedings of the conference, volume 2016, pp. 1648. NIH Public Access, 2016.
+
+George Konidaris. On the necessity of abstraction. Current Opinion in Behavioral Sciences, 29: 1–7, 2019.
+
+George Konidaris and Andrew Barto. Efficient skill learning using abstraction selection. In TwentyFirst International Joint Conference on Artificial Intelligence, 2009a.
+
+George Konidaris and Andrew Barto. Skill discovery in continuous reinforcement learning domains using skill chaining. In Advances in Neural Information Processing Systems, pp. 1015–1023, 2009b.
+
+George Konidaris, Scott Kuindersma, Roderic Grupen, and Andrew Barto. Robot learning from demonstration by constructing skill trees. The International Journal of Robotics Research, 31(3): 360–375, 2012.
+
+George Konidaris, Leslie Pack Kaelbling, and Tomas Lozano-Perez. From skills to symbols: Learning symbolic representations for abstract high-level planning. Journal of Artificial Intelligence Research, 61:215–289, 2018.
+
+Visak CV Kumar, Sehoon Ha, and C Karen Liu. Expanding motor skills using relay networks. In Conference on Robot Learning, pp. 744–756, 2018.
+
+Andrew Levy, Robert Platt, and Kate Saenko. Hierarchical reinforcement learning with hindsight. In International Conference on Learning Representations, 2019. URL https://openreview. net/forum?id ${ . } = { }$ ryzECoAcY7.
+
+Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015.
+
+Long-Ji Lin. Reinforcement learning for robots using neural networks. Technical report, CarnegieMellon Univ Pittsburgh PA School of Computer Science, 1993.
+
+Miao Liu, Marlos C Machado, Gerald Tesauro, and Murray Campbell. The eigenoption-critic framework. arXiv preprint arXiv:1712.04065, 2017.
+
+Marlos C. Machado, Clemens Rosenbaum, Xiaoxiao Guo, Miao Liu, Gerald Tesauro, and Murray Campbell. Eigenoption discovery through the deep successor representation. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum? id $=$ Bk8ZcAxR-.
+
+Amy McGovern and Richard S Sutton. Macro-actions in reinforcement learning: An empirical analysis. Computer Science Department Faculty Publication Series, pp. 15, 1998.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529, 2015.
+
+Ofir Nachum, Shixiang Shane Gu, Honglak Lee, and Sergey Levine. Data-efficient hierarchical reinforcement learning. In Advances in Neural Information Processing Systems, pp. 3303–3313, 2018.
+
+Scott Niekum and Andrew G. Barto. Clustering via dirichlet process mixture models for portable skill discovery. In J. Shawe-Taylor, R. S. Zemel, P. L. Bartlett, F. Pereira, and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems 24, pp. 1818–1826. Curran Associates, Inc., 2011.
+
+F. Pedregosa, G. Varoquaux, A. Gramfort, V. Michel, B. Thirion, O. Grisel, M. Blondel, P. Prettenhofer, R. Weiss, V. Dubourg, J. Vanderplas, A. Passos, D. Cournapeau, M. Brucher, M. Perrot, and E. Duchesnay. Scikit-learn: Machine learning in Python. Journal of Machine Learning Research, 12:2825–2830, 2011.
+
+Marc Pickett and Andrew G Barto. Policyblocks: An algorithm for creating useful macro-actions in reinforcement learning. In ICML, volume 19, pp. 506–513, 2002.
+
+Matthew Riemer, Miao Liu, and Gerald Tesauro. Learning abstract options. In Advances in Neural Information Processing Systems, pp. 10424–10434, 2018.
+
+Tom Schaul, Daniel Horgan, Karol Gregor, and David Silver. Universal value function approximators. In International conference on machine learning, pp. 1312–1320, 2015.
+
+Jurgen Schmidhuber. Learning to generate sub-goals for action sequences. In ¨ Artificial neural networks, pp. 967–972, 1991.
+
+Archit Sharma, Shixiang Gu, Sergey Levine, Vikash Kumar, and Karol Hausman. Dynamics-aware unsupervised discovery of skills. arXiv preprint arXiv:1907.01657, 2019.
+
+David Silver and Kamil Ciosek. Compositional planning using optimal option models. In ICML, 2012.
+
+Ozg ¨ ur S¸ ims¸ek and Andrew G Barto. Using relative novelty to identify useful temporal abstractions ¨ in reinforcement learning. In Proceedings of the twenty-first international conference on Machine learning, pp. 95. ACM, 2004.
+
+Ozg ¨ ur S¸ ims¸ek, Alicia P Wolfe, and Andrew G Barto. Identifying useful subgoals in reinforcement ¨ learning by local graph partitioning. In Proceedings of the 22nd international conference on Machine learning, pp. 816–823. ACM, 2005.
+
+Matthew Smith, Herke van Hoof, and Joelle Pineau. An inference-based policy gradient method for learning options. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 4703–4712, Stockholmsmassan, Stockholm Sweden, 10–15 Jul 2018. PMLR. URL ¨ http: //proceedings.mlr.press/v80/smith18a.html.
+
+Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT press, 2018.
+
+Richard S Sutton, Doina Precup, and Satinder P Singh. Intra-option learning about temporally abstract actions. In ICML, volume 98, pp. 556–564, 1998.
+
+Richard S Sutton, Joseph Modayil, Michael Delp, Thomas Degris, Patrick M Pilarski, Adam White, and Doina Precup. Horde: A scalable real-time architecture for learning knowledge from unsupervised sensorimotor interaction. In The 10th International Conference on Autonomous Agents and Multiagent Systems-Volume 2, pp. 761–768. International Foundation for Autonomous Agents and Multiagent Systems, 2011.
+
+R.S. Sutton, , D. Precup, and S. Singh. Between MDPs and semi-MDPs: A framework for temporal abstraction in reinforcement learning. Artificial Intelligence, 112(1):181–211, 1999.
+
+Haoran Tang, Rein Houthooft, Davis Foote, Adam Stooke, OpenAI Xi Chen, Yan Duan, John Schulman, Filip DeTurck, and Pieter Abbeel. # exploration: A study of count-based exploration for deep reinforcement learning. In Advances in neural information processing systems, pp. 2753– 2762, 2017.
+
+Russ Tedrake. LQR-trees: Feedback motion planning on sparse randomized trees. 2009.
+
+Gerald Tesauro. TD-Gammon, a self-teaching backgammon program, achieves master-level play. Neural computation, 6(2):215–219, 1994.
+
+Saket Tiwari and Philip S Thomas. Natural option critic. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 5175–5182, 2019.
+
+Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In 2012 IEEE/RSJ International Conference on Intelligent Robots and Systems, pp. 5026–5033. IEEE, 2012.
+
+Hado Van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double Qlearning. In Thirtieth AAAI Conference on Artificial Intelligence, 2016.
+
+Alexander Sasha Vezhnevets, Simon Osindero, Tom Schaul, Nicolas Heess, Max Jaderberg, David Silver, and Koray Kavukcuoglu. Feudal networks for hierarchical reinforcement learning. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 3540– 3549. JMLR. org, 2017.
+
+Christopher JCH Watkins and Peter Dayan. Q-learning. Machine learning, 8(3-4):279–292, 1992.
+
+Shangtong Zhang and Shimon Whiteson. DAC: The double actor-critic architecture for learning options. In Advances in neural information processing systems, pp. To appear, 2019. URL https://arxiv.org/abs/1904.12691.
+
+![](images/a31fe876124f6b27d5b272d4ef15b760805230e8aa0bc8f3fa175cb28f3d9f21.jpg)  
+Figure 4: An illustration of the deep skill chaining algorithm. $\star$ represents the goal state, $\times$ represents the two start states. (a) Before the agent has discovered its first skill/option, it acts according to its global DDPG policy. Having encountered the goal state $N$ times, the agent creates an option to trigger the goal from its local neighborhood. (b) Now, when the agent enters the initiation set of the first option, it begins to learn another option to trigger the first option. (c) Because the agent has two different start states, it learns two qualitatively different options to trigger the option learned in (b). (d) Finally, the agent has learned a skill tree which it can follow to consistently reach the goal.
+
+# A APPENDIX
+
+# A.1 CREATING SKILL TREES
+
+In Section 3.4, we introduced the idea of generalizing skill chains to skill trees to incorporate qualitatively different solution trajectories. In this section, we provide some of the implementation details required to learn initiation set classifiers that organize in the form of trees.
+
+When creating skill chains, the goal of each option is to trigger the initiation condition of the option that precedes it in its chain (i.e, its parent option). When creating a skill tree of branching factor $B$ , we allow at most $B$ options to target each salient event in the MDP (i.e, the goal state and the initiation set classifiers of preexisting options). To further control the branching factor of the skill tree, we impose two more conditions on option creation:
+
+1. Consider an option $o _ { 1 }$ which already has one child option $o _ { 2 }$ targeting it. Now suppose that we want to learn another option $o _ { 3 }$ that also targets $o _ { 1 }$ . We only consider state $s _ { t }$ to be a positive example for training $\mathcal { T } _ { o _ { 3 } }$ if $\mathcal { T } _ { o _ { 2 } } ( s _ { t } ) = 0$ . 2. To prevent significant overlap between options that target the same event, we treat the positive examples used to train the initiation set classifier of one as negative training examples of all its sibling options. This allows for multiple options that trigger the same target event, while encouraging them to specialize in different parts of the state-space.
+
+In the Point E-Maze task considered in Section 4, we learn a skill tree with $B = 2$
+
+# A.2 INTRA-OPTION Q-LEARNING
+
+In principle, the methodology outlined in Section 3.2 is sufficient to learn an effective policy over options $\pi _ { \mathcal { O } }$ . However, when $\mathcal { O }$ is a set of Markov options (Sutton et al., 1999), which is the setting considered in this paper, we can use intra-option Q-learning (Sutton et al., 1998) to improve the sample efficiency associated with learning $\pi _ { \mathcal { O } }$ .
+
+More specifically, given a transition $( s _ { t } , o , r _ { t : t + \tau } , s _ { t + \tau } )$ , SMDP Q-learning treats option $o$ as a black box and uses Equation 4 to determine the Q-value target $y _ { t }$ for updating $\pi _ { \mathcal { O } }$ . Intra-option Q-learning leverages the fact that option $o$ is Markov to point out that all the transitions experienced during the execution of $o$ are also valid experiences for training $\pi _ { \mathcal { O } }$ . As long as a state $s _ { t + i } , \forall i \in [ 0 , \tau ]$ is inside the initiation set of the option $o$ , we can pretend that option execution really began in state $s _ { t + i }$ and add the transition $( s _ { t + i } , o , r _ { t + i : t + \tau } , s _ { t + \tau } )$ to the $\pi _ { \mathcal { O } }$ ’s replay buffer.
+
+Furthermore, intra-option Q-learning also provides a way to improve the sample efficiency associated with learning option policies $\pi _ { o } , \forall o \in { \mathcal { O } }$ . This can be done by making off-policy updates to each option’s internal policy. In other words, regardless of which option is actually executed in the MDP, as long as a state experienced during execution is inside the initiation set of some other option, we can add the associated experience tuple to that (un-executed) option’s replay buffer. Note that this is possible because we use an off-policy learning algorithm (DDPG) to learn intra-option policies.
+
+# A.3 TEST ENVIRONMENTS
+
+A description of the Four Rooms and the Point E-Maze tasks was provided in Section 4. Here we describe the remaining tasks considered in this paper:
+
+Point Maze: In this task, the same point agent as in the four rooms task must navigate around a U-shaped maze to reach its goal. The agent receives a reward of $- 1$ for every step it lives, and a sparse terminating reward of 0 when it reaches its goal location. This is an interesting task for hierarchical agents because in order to reach the goal, the agent must first move away from it. It is clear that a dense distance-based reward formulation of this problem would only serve to deceive non-hierarchical agents such as DDPG.
+
+Ant Maze: The ant (Duan et al., 2016) is a challenging agent to control due to its non-linear and highly unstable dynamics. In this task, the ant must now navigate around the same U-shaped maze as in the Point Maze task. Getting the ant to cover significant distances along the $x , y$ plane without falling over, is a benchmark control task itself (Brockman et al., 2016). As a result, constructing options backward from the goal could require prohibitively large training episodes or the use of a sophisticated exploration algorithms (Burda et al., 2019; Bellemare et al., 2016; Tang et al., 2017). To avoid conflating our results with the orthogonal investigation of effective exploration in RL, we follow the experimental design of other state-of-the-art hierarchical reinforcement learning algorithms (Levy et al., 2019; Nachum et al., 2018) and sample the initial state of the ant uniformly across the maze for the first 30 episodes. For fair comparison, all baseline algorithms use this exploration strategy.
+
+Fixed Reacher: We use the Reacher task (Brockman et al., 2016) with two modifications. First, rather than randomly sampling a new goal at the start of each episode, we fix the target across all episodes. We do this because if the goal moves, following a learned skill chain will no longer solve the MDP. Note that the same modification was made in the DDPG paper (Lillicrap et al., 2015). Second, to increase the difficulty of the resulting task, we use a sparse reward function rather than the dense distance-based one used in the original formulation.
+
+Table 1: Maximum number of time steps per episode in each of the experimental domains   
+
+<table><tr><td>Task</td><td>Number of steps per episode</td></tr><tr><td>Point-Maze</td><td>1000</td></tr><tr><td>Four Rooms with Lock and Key</td><td>5000</td></tr><tr><td>Point E-Maze</td><td>1500</td></tr><tr><td>Reacher</td><td>500</td></tr><tr><td>Ant-Maze</td><td>2000</td></tr></table>
+
+![](images/b5fd9a8aeadb9b741a2285df1519103a27534cbc81265ce00e546732b369bbab.jpg)  
+Figure 5: Analysis of performance (as measured by mean cumulative reward) of DSC agent as it is allowed to learn more skills in (a) Point-Maze, (b) Four Rooms with Lock and Key, (c) E-Maze and (d) Ant-Maze. Note that in general, DSC discovers as many skills as it needs to solve the given problem. For this experiment alone, we restrict the number of skills that the DSC agent can learn. All experiments averaged over 5 runs. Error bars denote 1 standard deviation. Higher is better.
+
+![](images/ecd37dd6134140018731ede6dff36800431561434531484a2551f96d47a907d5.jpg)  
+Figure 6: Initiation set classifiers learned in the Point E-Maze domain. Discovered skills organize in the form of a tree with a branching factor of 2. The option on the extreme left initiates in the proximity of the goal. Options learned after the goal option branch off into two separate skill chains. The chain on top extends backward to the start state in the top rung of the E-Maze. The chain shown in the bottom row extends backward to the start state in the bottom rung of the E-Maze.
+
+A.4 ABLATION STUDY
+
+A.4.1 PERFORMANCE AS A FUNCTION OF NUMBER OF SKILLS
+
+Deep skill chaining generally discovers and learns as many skills as it needs to solve a given problem. In this experiment however, we restrict the number of skills DSC can learn to examine its impact on overall agent performance (as measured by cumulative reward during training). Figure 5 shows that the performance of the agent increases monotonically (with diminishing marginal improvements) as it is allowed to learn more skills.
+
+A.4.2 NUMBER OF SKILLS OVER TIME
+
+Figures 7 (a) and 7 (b) illustrate how deep skill chaining incrementally discovers options and adds it to the agent’s option repertoire. Figure 7(c) shows how the number of skills empirically increases over time, plateaus and has low variance between runs. Since the agent has to learn the importance of the key in the Four Rooms task, learning initiation set classifiers takes longer than in the Point-Maze task.
+
+# A.4.3 HYPERPARAMETER SENSITIVITY
+
+In this section, we analyze DSC’s sensitivity to some of the hyperparameters specific to the algorithm. In Figure 8, we show that even under a fairly large range of values for the buffer length $K$ and the gestation period $N$ , DSC is able to retain its strong performance.
+
+![](images/c3d2982704132df960ad0ee2003ed8d7eae95a315cd07c5f0d5bd673ebc3ca4d.jpg)  
+Figure 7: (a) Initially, the policy over options $\pi _ { \mathcal { O } }$ can only choose the global option $o _ { G }$ as a proxy for selecting primitive actions. (b) Over time, the agent learns temporally extended skills and adds output nodes to the final layer of the DQN parameterizing $\pi _ { \mathcal { O } }$ . This continues until the start state $s _ { 0 }$ lies inside the initiation set of a learned option. (c) Empirical evaluation of how the number of skills in the agent’s option repertoire changes over time in Point-Maze and Four-Rooms with a Lock and Key.
+
+![](images/d956447d8fe51e03b6f46f81b4592ccaea446ed99bd7de7161dc8def31572719.jpg)  
+Figure 8: Variation in DSC performance (as measured by mean cumulative reward) as a function of two hyperparameters: (left) the buffer length $K$ and (right) the gestation period $N$ of the option. For a qualitative description of both hyperparameters, refer to Section 3.3. This experiment shows that DSC is fairly robust to most reasonable choices of these parameters. All experiments averaged over 5 runs. Error bars denote 1 standard deviation. Higher is better.
+
+#
+
+A.5 ALGORITHM PSEUDO-CODE   
+
+<table><tr><td>Algorithm1: Deep Skill Chaining So is the start state of the MDP</td></tr><tr><td>1g(s) := 1 if s is a target state in the MDP, O otherwise</td></tr><tr><td>Given hyperparameter To, the time budget for discovered, temporally extended options Global option: 0G = (Iog,Tog,βoG = 1g,T=1) Goaloption:0g=(Igβog=1g,T=T)</td></tr><tr><td>Agent&#x27;s option repertoire: O={0G}</td></tr><tr><td>Untrained Option: ou = og //option whose initiation classifier is yet unlearned</td></tr><tr><td></td></tr><tr><td>Policy over options: πo: St → 0t</td></tr><tr><td>St = S0</td></tr><tr><td>while not st.is_terminal() do</td></tr><tr><td>1. Pick new option and execute in environment</td></tr><tr><td>Choose Ot according to πo(st） using Equations 2 and 3</td></tr><tr><td>rt:t,St+r = execute_option(Ot)</td></tr><tr><td>TO.update(St, Ot, rt:t+r, St+r) using Equation 4</td></tr><tr><td>2.Learn initiation set of new option</td></tr><tr><td>// Collect trajectories that trigger Ou&#x27;s termination region unless we have finished chaining</td></tr><tr><td>if βou(st+r)&amp;(soeI∀oi ∈O) then ou.learn_initiation_classifier() using procedure described in Section 3.3</td></tr><tr><td>if ou.initiation_classifier_is_trained() then</td></tr><tr><td>T.add(ou） using procedure described in Section 3.2</td></tr><tr><td>O.append(ou)</td></tr><tr><td>Ou = create_child_option(ou)</td></tr><tr><td>end</td></tr><tr><td>end</td></tr><tr><td>end</td></tr><tr><td>Function create_child_option (o) : &quot; Create a new option whose β is the parent&#x27;s I.</td></tr><tr><td>0* = Option() // Create a new option</td></tr><tr><td>Lo* =None</td></tr><tr><td>β*=I</td></tr><tr><td>return 0*</td></tr><tr><td>Function execute_option (ot) :</td></tr><tr><td>&quot;&quot;” Option control loop. ；””</td></tr><tr><td>to=t</td></tr><tr><td>Tis the option&#x27;s episodic time budget</td></tr><tr><td>Tot is the option&#x27;s internal policy</td></tr><tr><td></td></tr><tr><td>while not βot(st)&amp;t&lt;Tdo</td></tr><tr><td>at= Tot(St;0ot）</td></tr><tr><td>Tt, St+1 = env.step(at)</td></tr><tr><td></td></tr><tr><td>St=St+1</td></tr><tr><td>t=t+1</td></tr><tr><td></td></tr><tr><td></td></tr><tr><td>end</td></tr><tr><td></td></tr><tr><td>T=t// duration ofoption execution</td></tr></table>
+
+# A.6 MORE DETAILS ON IMPLEMENTING OPTION REWARD FUNCTIONS
+
+Section 3.1 explains that to learn an option’s intra-option policy, we must define its internal reward function. While most of our experiments are conducted in the sparse-reward setting, deep skill chaining can be used without much modification in dense reward tasks as well. All that remains is a clear description of how each option’s internal reward function would be defined in such a setting.
+
+Consider an option $o _ { i }$ with parent option $o _ { i - 1 }$ such that $\beta _ { o _ { i } } = \mathcal { T } _ { o _ { i - 1 } }$ . In the dense reward setting, we use the negative distance from the state to the parent option’s initiation classifier as the reward function. Since initiation classifiers are represented using parametric classifiers, computing the distance to the classifier’s decision boundary is straightforward and can be done using most popular machine learning frameworks. For instance, when using scikit-learn (Pedregosa et al., 2011), this is implemented as follows:
+
+$$
+R _ { o } ( s , a , s ^ { \prime } ) = \left\{ \begin{array} { l l } { 0 , } & { \mathrm { i f ~ } \beta _ { o } ( s ^ { \prime } ) = 1 } \\ { - \mathscr { T } _ { o _ { i - 1 } . \mathrm { d e c i s i o n . f u n c t i o n } ( s ^ { \prime } ) , } } & { \mathrm { o t h e r w i s e } } \end{array} \right.
+$$
+
+Where in Equation 5, decision function $( x )$ returns the distance in feature space between point $\boldsymbol { x } \in \mathbb { R } ^ { \dot { N } }$ and the decision boundary learned by the classifier $\mathcal { T } _ { o _ { i - 1 } }$ .
+
+# A.7 LEARNING INITIATION SET CLASSIFIERS
+
+To learn initiation set classifiers as described in Section 3.3, we used scikit-learn’s One-Class SVM and Two-Class SVM packages (Pedregosa et al., 2011). Initiation set classifiers were learned on a subset of the state variables available in the domain. For instance, in the Lock and Key domain, the initiation set classifier was learned over the $x , y$ position and the has key indicator variable. This is similar to other methods like HAC (Levy et al., 2019) which require the user to specify the dimensions of the state variable necessary to achieve the overall goal of the MDP. Incorporating the entire state variable to learn initiation set classifiers or using neural networks for automatic feature extraction should be straightforward and is left as future work.
+
+# A.8 HYPERPARAMETER SETTINGS
+
+We divide the full set of hyperparameters that our algorithm depends on into two groups: those that are common to all algorithms that use DDPG (Table 2), and those that are specific to skill chaining (Table 3). We did not try to optimize over the space of DDPG hyperparameters, and used the ones used in previous work (Lillicrap et al., 2015; Fujimoto et al., 2018). Table 3 shows the hyperparameters that we chose on the different tasks considered in this paper. Most of them are concerned with learning initiation set classifiers, the difficulty of which varies based on domain. To determine the correct setting of these parameters, we usually visualized the learned initiation set classifiers during the course of training (like Figures 2 and 6), and made adjustments accordingly.
+
+Table 2: DDPG Hyperparameters   
+
+<table><tr><td>Parameter</td><td>Value</td></tr><tr><td>Replay buffer size</td><td>1e6</td></tr><tr><td>Batch size</td><td>64</td></tr><tr><td>Y</td><td>0.99</td></tr><tr><td>T</td><td>0.01</td></tr><tr><td>Number of hidden layers</td><td>2</td></tr><tr><td>Hidden size 1</td><td>400</td></tr><tr><td>Hidden size 2</td><td>300</td></tr><tr><td>Critic learning rate</td><td>1e-3</td></tr><tr><td>Actor learning rate</td><td>le-4</td></tr></table>
+
+Table 3: Deep Skill Chaining Hyperparameters   
+
+<table><tr><td>Parameter</td><td> Point Maze</td><td>Four Rooms</td><td>Reacher</td><td> Ant Maze</td><td>E-Maze</td></tr><tr><td>Gestation Period (N)</td><td>5</td><td>10</td><td>5</td><td>1</td><td>5</td></tr><tr><td>Initiation Period</td><td>1</td><td>10</td><td>3</td><td>0</td><td>1</td></tr><tr><td>Buffer Length (K)</td><td>20</td><td>20</td><td>20</td><td>750</td><td>20</td></tr><tr><td>Option Max Time Steps (T)</td><td>100</td><td>150</td><td>150</td><td>100</td><td>100</td></tr></table>
+
+# A.9 COMPUTE INFRASTRUCTURE
+
+We used 1 NVIDIA GeForce 2080 Ti, 2 NVIDIA GeForce $2 0 7 0 \mathrm { T i }$ and 2 Tesla K80s on the Google Cloud compute infrastructure to perform all experiments reported in this paper.
+
+# A.10 NOTE ON COMPUTATION TIME
+
+Each option is parameterized by its own neural networks, which are only updated when the agent is inside that option’s initiation set. For a given transition, this leads to at most two or three updates. In Point-Maze, updating all options on a transition took $0 . 0 0 4 \pm 0 . 0 0 0 3$ s more than just updating the global DDPG agent (averaged over 300 episodes using 1 NVIDIA 2080 Ti GPU) - a trivial amount of extra computation time.

parse/train/B1gqipNYwH/B1gqipNYwH_content_list.json

@@ -0,0 +1,1974 @@
+[
+    {
+        "type": "text",
+        "text": "OPTION DISCOVERY USING DEEP SKILL CHAINING ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            98,
+            790,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Akhil Bagaria ",
+        "text_level": 1,
+        "bbox": [
+            184,
+            145,
+            284,
+            159
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "George Konidaris ",
+        "text_level": 1,
+        "bbox": [
+            509,
+            145,
+            633,
+            159
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Department of Computer Science Brown University   \nProvidence, RI, USA   \nakhil bagaria@brown.edu   \nDepartment of Computer Science   \nBrown University   \nProvidence, RI, USA   \ngdk@brown.edu ",
+        "bbox": [
+            184,
+            160,
+            406,
+            214
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            509,
+            160,
+            730,
+            214
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            252,
+            544,
+            267
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Autonomously discovering temporally extended actions, or skills, is a longstanding goal of hierarchical reinforcement learning. We propose a new algorithm that combines skill chaining with deep neural networks to autonomously discover skills in high-dimensional, continuous domains. The resulting algorithm, deep skill chaining, constructs skills with the property that executing one enables the agent to execute another. We demonstrate that deep skill chaining significantly outperforms both non-hierarchical agents and other state-of-the-art skill discovery techniques in challenging continuous control tasks.1 2 ",
+        "bbox": [
+            233,
+            281,
+            764,
+            392
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            416,
+            336,
+            431
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hierarchical reinforcement learning (Barto & Mahadevan, 2003) is a promising approach for solving long-horizon sequential decision making problems. Hierarchical methods lower the decision making burden on the agent through the use of problem specific action abstractions (Konidaris, 2019). While the use of temporally extended actions, or options (Sutton et al., 1999), has been shown to accelerate learning (McGovern & Sutton, 1998), there remains the question of skill discovery: how can agents autonomously construct useful skills via interaction with the environment? While a large body of work has sought to answer this question in small discrete domains, skill discovery in high-dimensional continuous spaces remains an open problem. ",
+        "bbox": [
+            174,
+            446,
+            825,
+            558
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "An early approach to skill discovery in continuous-state environments was skill chaining (Konidaris & Barto, 2009b), where an agent constructs a sequence of options that target a salient event in the MDP (for example, the goal state). The skills are constructed so that successful execution of each option in the chain allows the agent to execute another option, which brings it closer still to its eventual goal. While skill chaining was capable of discovering skills in continuous state spaces, it could only be applied to relatively low-dimensional state-spaces with discrete actions. ",
+        "bbox": [
+            174,
+            565,
+            825,
+            648
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We introduce a new algorithm that combines the core insights of skill chaining with recent advances in using non-linear function approximation in reinforcement learning. The new algorithm, deep skill chaining, scales to high-dimensional problems with continuous state and action spaces. Through a series of experiments on five challenging domains in the MuJoCo physics simulator (Todorov et al., 2012), we show that deep skill chaining can solve tasks that otherwise cannot be solved by nonhierarchical agents in a reasonable amount of time. Furthermore, the new algorithm outperforms state-of-the-art deep skill discovery algorithms (Bacon et al., 2017; Levy et al., 2019) in these tasks. ",
+        "bbox": [
+            174,
+            655,
+            825,
+            753
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND AND RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            772,
+            511,
+            789
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sequential decision making problems can be formalized as Markov Decision Processes (MDPs). We consider goal-oriented episodic MDPs, where $S$ denotes the state space, $A$ is the action space, $R$ is the reward function, $\\tau$ is the transition function, $\\gamma$ is the discount factor and $g \\in S$ is the terminating goal state (Sutton & Barto, 2018). Unlike goal-conditioned algorithms (Sutton et al., 2011; Schaul et al., 2015), we do not require that $g$ be known; instead we assume access to an indicator function $\\mathbb { 1 } _ { g } : s \\in S  \\{ 0 , 1 \\}$ which the agent can query to determine if it has reached the MDP’s goal. ",
+        "bbox": [
+            174,
+            803,
+            823,
+            887
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One way to learn a policy in an MDP is to first learn an action-value function. The action-value function $Q ^ { \\pi } ( s _ { t } , a _ { t } )$ is defined as the expected sum of discounted future rewards if the agent takes action $a _ { t }$ from $s _ { t }$ and then follows policy $\\pi$ thereafter: $\\begin{array} { r } { Q ^ { \\pi } ( s _ { t } , a _ { t } ) = \\mathbb { E } _ { \\pi } [ r _ { t } + \\gamma \\operatorname* { m a x } _ { a _ { t + 1 } } \\bar { Q } ^ { \\pi } ( s _ { t + 1 } , a _ { t + 1 } ) ] } \\end{array}$ . ",
+        "bbox": [
+            174,
+            103,
+            823,
+            147
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Q-learning (Watkins & Dayan, 1992) is a commonly used off-policy algorithm that uses the actionvalue function for control through a greedy policy $\\pi ( s _ { t } ) = \\arg \\operatorname* { m a x } _ { a _ { t } } Q ( s _ { t } , a _ { t } )$ . Inspired by recent success in scaling Q-learning to high-dimensional spaces (Mnih et al., 2015; Van Hasselt et al., 2016; Lillicrap et al., 2015; Tesauro, 1994), we learn the action-value function $Q _ { \\phi } ^ { \\pi } ( s _ { t } , a _ { t } )$ using non-linear function approximators parameterized by $\\phi$ , by minimizing the loss $L ( \\phi ) = \\mathbb { E } _ { \\pi } [ ( Q _ { \\phi } ( s _ { t } , a _ { t } ) - y _ { t } ) ^ { 2 } ]$ where the Q-learning target $y _ { t }$ is given by the following equation (Van Hasselt et al., 2016): ",
+        "bbox": [
+            174,
+            151,
+            825,
+            239
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f0bd4f82331b656939450b1c0301433cebb6383002c83b031a5e8435fff7cfe6.jpg",
+        "text": "$$\ny _ { t } = r _ { t } + \\gamma Q _ { \\phi ^ { \\prime } } \\bigl ( s _ { t + 1 } , \\underset { a _ { t + 1 } } { \\arg \\operatorname* { m a x } } Q _ { \\phi } \\bigl ( s _ { t + 1 } , a _ { t + 1 } \\bigr ) \\bigr ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            258,
+            660,
+            285
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Deep Q-Learning (DQN) (Mnih et al., 2015) casts minimizing $L ( \\phi )$ as a standard regression problem by using target networks (parameterized by $\\phi ^ { \\prime }$ ) and experience replay (Lin, 1993). ",
+        "bbox": [
+            173,
+            300,
+            823,
+            329
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 THE OPTIONS FRAMEWORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            345,
+            408,
+            361
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The options framework (Sutton et al., 1999) models skills as options. An option $o$ consists of three components: (a) its initiation condition, $\\mathcal { T } _ { o } ( s )$ , which determines whether $o$ can be executed in state $s$ , (b) its termination condition, $\\beta _ { o } ( s )$ , which determines whether option execution must terminate in state $s$ and (c) its closed-loop control policy, $\\pi _ { o } ( s )$ , which maps state $s$ to a low level action $a \\in A$ . Augmenting the set of available actions with options results in a Semi-Markov Decision Process (SMDP) (Sutton et al., 1999) where the next state depends on the current state, action and time. ",
+        "bbox": [
+            174,
+            371,
+            825,
+            455
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 SKILL DISCOVERY ALGORITHMS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            473,
+            442,
+            487
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Skill discovery has been studied extensively in small discrete domains (McGovern & Sutton, 1998; S¸ ims¸ek & Barto, 2004; S¸ ims¸ek et al., 2005; Bakker & Schmidhuber, 2004; Schmidhuber, 1991; Pickett & Barto, 2002; Dietterich, 2000). Recently however, there has been a significant body of work aimed at discovering skills in continuous spaces. ",
+        "bbox": [
+            174,
+            498,
+            825,
+            555
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Option-critic methods: Option-Critic (Bacon et al., 2017) uses an end-to-end gradient based algorithm to learn options in high-dimensional continuous spaces. Option-Critic was a substantial step forward in skill discovery and led to a family of related methods (Klissarov et al., 2017; Tiwari & Thomas, 2019; Riemer et al., 2018; Liu et al., 2017; Jain et al., 2018). Proximal Policy Option Critic (PPOC) (Klissarov et al., 2017) extends Option-Critic to continuous action spaces and is the version of Option-Critic that we compare against in this paper. Our method bypasses two fundamental shortcomings of the Option-Critic framework: (a) unlike Option-Critic, we explicitly learn initiation sets of options and thus do not assume that all options are executable from everywhere, and (b) we do not treat the number of skills required to solve a task as a fixed and costly hyperparameter. Instead, our algorithm flexibly discovers as many skills as it needs to solve the given problem. ",
+        "bbox": [
+            174,
+            561,
+            825,
+            702
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Feudal methods: An alternative to the options framework is Feudal RL (Dayan & Hinton, 1993), which creates a hierarchy in which managers learn to assign subgoals to workers; workers take a subgoal state as input and learn to reach it. Feudal Networks (FuN) (Vezhnevets et al., 2017) used neural networks to scale the Feudal-RL framework to high-dimensional continuous spaces; it was extended and outperformed by HIRO (Nachum et al., 2018) in a series of control tasks in the MuJoCo simulator. More recently, Hierarchical Actor-Critic (HAC) (Levy et al., 2019) outperformed HIRO in a similar suite of continuous control problems. While HIRO relies on having a dense “distanceto-goal” based reward function to train both levels of their feudal hierarchy, HAC’s use of Hindsight Experience Replay (HER) (Andrychowicz et al., 2017) allows it to work in the more general sparsereward setting. Given its strong performance in continuous control problems and its ability to learn effectively in sparse-reward settings, we compare against HAC as a representative feudal method. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            861
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Learning backward from the goal: The idea of sequencing locally applicable controllers is well established in robotics and control theory in the form of pre-image backchaining (Kaelbling & LozanoPerez, 2017) and LQR-Trees (Tedrake, 2009). Such methods either require individually engineered ´ control loops or a model of the system dynamics. Our work fits in the model-free RL setting and thus requires neither. More recently, reverse curriculum learning (Florensa et al., 2017) also learns backward from the goal. However, they define a curriculum of start states to learn a single policy, rather than learning skills. Relay Networks (Kumar et al., 2018) segment the value function backward from the goal using a thresholding scheme, which makes their method reliant on the accurate estimation of the value function. By contrast, our algorithm is agnostic to errors in value estimation, which are unavoidable when using function approximation in high-dimensional spaces. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            188
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Planning with learned skills: Options have been shown to empirically speed up planning in several domains (Silver & Ciosek, 2012; Jinnai et al., 2019; James et al., 2018; Francis & Ram, 1993; Konidaris, 2016; Sharma et al., 2019). However, Konidaris et al. (2018) show that for resulting plans to be provably feasible, skills must be executable sequentially. While they assume that such skills are given, we show that they can be autonomously discovered in high-dimensional spaces. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            263
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 DEEP SKILL CHAINING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            285,
+            400,
+            301
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Deep skill chaining (DSC) is based on the intuition that it is easier to solve a long-horizon task from states in the local neighborhood of the goal. This intuition informs the first step of the algorithm: create an option that initiates near the goal and reliably takes the agent to the goal. Once such an option is learned, we create another option whose goal is to take the agent to a state from which it can successfully execute the first option. Skills are chained backward in this fashion until the start state of the MDP lies inside the initiation set of some option. The inductive bias of creating sequentially executable skills guarantees that as long as the agent successfully executes each skill in its chain, it will solve the original task. More formally, skill chaining amounts to learning options such that the termination condition $\\beta _ { o _ { i } } ( s _ { t } )$ of an option $o _ { i }$ is the initiation condition $\\mathcal { T } _ { o _ { i - 1 } } ( s _ { t } )$ of the option that precedes it in its chain. ",
+        "bbox": [
+            174,
+            318,
+            825,
+            457
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our algorithm proceeds as follows: at time $t$ , the policy over options $\\pi _ { \\mathcal { O } } : s _ { t } \\in S  o \\in \\mathcal { O }$ determines which option to execute (Section 3.2). Control is then handed over to the selected option $o _ { i }$ ’s internal policy $\\pi _ { o _ { i } } : s \\in S \\to a _ { t } \\in \\mathbb { R } ^ { | A | }$ . $\\pi _ { o _ { i } }$ outputs joint torques until it either reaches its goal $( \\beta _ { o _ { i } } : = \\mathbb { Z } _ { o _ { i - 1 } }$ ) or times out at its predetermined budget $T$ (Section 3.1). At this point, $\\pi _ { \\mathcal { O } }$ chooses another option to execute. If at any point the agent reaches the goal state of the MDP or the initiation condition of a previously learned option, it creates a new option to target such a salient event. The machinery for learning the initiation condition of this new option is described in Section 3.3. We now detail the components of our architecture and how they are learned. Readers may also refer to Figures $4 \\& 7$ and the pseudo-code in Appendix A.5 to gain greater intuition about our algorithm. ",
+        "bbox": [
+            174,
+            463,
+            825,
+            590
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 INTRA-OPTION POLICY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            608,
+            379,
+            622
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Each option $o$ maintains its own policy $\\pi _ { o } : s \\to a _ { t } \\in \\mathbb { R } ^ { | A | }$ , which is parameterized by its own neural networks $\\theta _ { o }$ . To train $\\pi _ { o } ( s ; \\theta _ { o } )$ , we must define $o$ ’s internal reward function. In sparse reward problems, $o$ is given a subgoal reward when it triggers $\\beta _ { o }$ ; otherwise it is given a step penalty. In the dense reward setting, we can compute the distance to the parent option’s initiation set classifier and use that to define $o$ ’s internal reward function. We can now treat learning the intra-option policy $( \\pi _ { o } )$ as a standard RL problem and use an off-the-shelf algorithm to learn this policy. Since in this work we solve tasks with continuous action spaces, we use Deep Deterministic Policy Gradient (DDPG) (Lillicrap et al., 2015) to learn option policies over real-valued actions. ",
+        "bbox": [
+            174,
+            633,
+            825,
+            747
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 POLICY OVER OPTIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            763,
+            380,
+            779
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Initially, the policy over options $\\left( \\pi _ { \\mathcal { O } } \\right)$ only possesses one option that operates over a single time step $T = 1$ ). We call this option the global option $( o _ { G } )$ since its initiation condition is true everywhere in the state space and its termination condition is true only at the goal state of the MDP (i.e, $\\mathcal { T } _ { o _ { G } } ( s ) =$ $1 \\forall s$ and $\\beta _ { o _ { G } } = 1 _ { g }$ ). Using $o _ { G } , \\pi _ { \\mathcal { O } }$ can select primitive actions. At first the agent continually calls upon $o _ { G }$ , which uses its internal option policy $\\pi _ { o _ { G } }$ to output exactly one primitive action. Once $o _ { G }$ triggers the MDP’s goal state $N$ times, DSC creates its first temporally extended option, the goal option $( o _ { g } )$ , whose termination condition is also set to be the goal state of the MDP, i.e, $\\beta _ { o _ { g } } = \\mathbb { 1 } _ { g }$ . ",
+        "bbox": [
+            174,
+            791,
+            825,
+            890
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As the agent discovers new skills, it adds them to its option repertoire and relies on $\\pi _ { \\mathcal { O } }$ to determine which option (including $o _ { G }$ ) it must execute at each state. Unlike $o _ { G }$ , learned options will be temporally extended, i.e, they will operate over $T > 1$ time steps. If in state $s _ { t }$ the agent chooses to execute option $o _ { i }$ , then $o _ { i }$ will execute its own closed-loop control policy (for $\\tau$ steps) until its termination condition is met $( \\tau < T )$ ) or it has timed out at $\\tau = T$ time steps. At this point, control is handed back to $\\pi _ { \\mathcal { O } }$ , which must now choose a new option at state $s _ { t + \\tau }$ . ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Option selection: To select an option in state $s _ { t } , \\pi _ { \\mathcal { O } }$ first constructs a set of admissible options given by Equation 2. $\\pi _ { \\mathcal { O } }$ then chooses the admissible option that maximizes its option-value function, as shown in Equation 3. Since the agent must choose from a discrete set of options at any time, we learn its option-value function using Deep Q-learning (DQN) (Mnih et al., 2015). ",
+        "bbox": [
+            173,
+            166,
+            823,
+            223
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5db6a18ba0cc0eba2bc8ffb72ccc62c9c9478d5368a92b71ccf97b4527fc0561.jpg",
+        "text": "$$\n\\begin{array} { c } { { \\mathcal { O } ^ { \\prime } ( s _ { t } ) = \\{ o _ { i } | \\mathcal { Z } _ { o _ { i } } ( s _ { t } ) = 1 \\cap \\beta _ { o _ { i } } ( s _ { t } ) = 0 , \\forall o _ { i } \\in \\mathcal { O } \\} } } \\\\ { { o _ { t } = \\arg \\operatorname* { m a x } Q _ { \\phi } ( s _ { t } , o _ { i } ) . } } \\\\ { { o _ { i } \\epsilon \\mathcal { O } ^ { \\prime } ( s _ { t } ) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            241,
+            669,
+            291
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Learning the option-value function: Given an SMDP transition $( s _ { t } , o _ { t } , r _ { t : t + \\tau } , s _ { t + \\tau } )$ , we update the value of taking option $o _ { t }$ in state $s _ { t }$ according to SMDP Q-learning update (Bradtke $\\&$ Duff, 1995). Since the agent learns Q-values for different state-option pairs, it may choose to ignore learned options in favor of primitive actions in certain parts of the state-space (in the interest of maximizing its expected future sum of discounted rewards). The Q-value target for learning the weights $\\phi$ of the DQN is given by: ",
+        "bbox": [
+            174,
+            303,
+            825,
+            387
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e081f713955c5c74b585d0ff79f93381de70e767cf0a6daf89863413cb5d423e.jpg",
+        "text": "$$\ny _ { t } = \\sum _ { t ^ { \\prime } = t } ^ { \\tau } \\gamma ^ { t ^ { \\prime } - t } r _ { t ^ { \\prime } } + \\gamma ^ { \\tau - t } Q _ { \\phi ^ { \\prime } } \\big ( s _ { t + \\tau } , \\ \\underset { o ^ { \\prime } \\epsilon \\mathcal O ^ { \\prime } ( s _ { t + \\tau } ) } { \\arg \\operatorname* { m a x } } \\ Q _ { \\phi } \\big ( s _ { t + \\tau } , o ^ { \\prime } \\big ) \\big ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            295,
+            404,
+            702,
+            445
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Adding new options to the policy over options: Equations 2, 3 and 4 show how we can learn the option-value function and use it for selecting options. However, we must still incrementally add new skills to the network during the agent’s lifetime. After the agent has learned a new option $o$ ’s initiation set classifier $\\mathcal { T } _ { o }$ (we will discuss how this happens in Section 3.3), it performs the following steps before it can add $o$ to its option repertoire: ",
+        "bbox": [
+            173,
+            455,
+            825,
+            526
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• To initialize $o$ ’s internal policy $\\pi _ { o }$ , the parameters of its DDPG $\\left( \\theta _ { o } \\right)$ are set to the parameters of the global agent’s DDPG $( \\theta _ { o _ { G } } )$ . Subsequently, their neural networks are trained independently. This provides a good starting point for optimizing $\\pi _ { o }$ , while allowing it to learn sub-problem specific abstractions.   \n• To begin predicting Q-values for $o$ , we add a new output node to final layer of the DQN parameterizing $\\pi _ { \\mathcal { O } }$ .   \n• We must assign appropriate initial values to $Q _ { \\phi } ( s , o )$ . We follow Konidaris & Barto (2009b) and collect all the transitions that triggered $\\beta _ { o }$ and use the max over these Q-values to optimistically initialize the new output node of our DQN.3 This is done by setting the bias of this new node, which ensures that the $\\mathrm { Q }$ -value predictions corresponding to the other options remain unchanged. ",
+        "bbox": [
+            173,
+            539,
+            825,
+            689
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 INITIATION SET CLASSIFIER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            707,
+            411,
+            722
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Central to the idea of learning skills is the ability to learn the set of states from which they can be executed. First, we must learn the initiation set classifier for $o _ { g }$ , the option used to trigger the MDP’s goal state. While acting in the environment, the agent’s global DDPG will trigger the goal state $N$ times (also referred to as the gestation period of the option by Konidaris & Barto (2009b) and Niekum & Barto (2011)). We collect these $N$ successful trajectories, segment the last $K$ states from each trajectory and learn a one-class classifier around the segmented states. Once initialized, it may be necessary to refine the option’s initiation set based on its policy. We do so by executing the option and collecting data to train a two-class classifier. States from which option execution was successful are labeled as positive examples. States from which option execution timed out are labeled as negative examples. We continue this process of refining the option’s initiation set classifier for a fixed number of episodes, which we call the initiation period of the option. ",
+        "bbox": [
+            174,
+            733,
+            825,
+            886
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "At the end of the initiation period, we fix the option’s initiation set classifier and add it to the list of salient events in the MDP. We then construct a new option whose termination condition is the initiation classifier of the option we just learned. We continue adding to our chain of options in this fashion until a learned initiation set classifier contains the start state of the MDP. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 GENERALIZING TO SKILL TREES ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            178,
+            442,
+            191
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our discussion so far has been focused on learning skill chains that extend from the goal to the start state of the MDP. However, such a chain is not sufficient if the agent has multiple start states or if we want the agent to learn multiple ways of solving the same problem. To permit such behavior, our algorithm can be used to learn skills that organize more generally in the form of trees (Konidaris & Barto, 2009b; Konidaris et al., 2012). This generalization requires some additional care while learning initiation set classifiers, the details of which can be found in Section A.1 of the Appendix. To demonstrate our ability to construct such skill trees (and their usefulness), we consider a maze navigation task, E-Maze, with distinct start states in Section 4. ",
+        "bbox": [
+            174,
+            203,
+            825,
+            314
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.5 OPTIMALITY OF DISCOVERED SOLUTIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            333,
+            509,
+            347
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Each option $o$ ’s internal policy $\\pi _ { o }$ is is given a subgoal reward only when it triggers its termination condition $\\beta _ { o }$ . As a result, $\\pi _ { o }$ is trained to find the optimal trajectory for entering its own goal region. Naively executing learned skills would thus yield a recursively optimal solution to the MDP (Barto & Mahadevan, 2003). However, since the policy over options $\\pi _ { \\mathcal { O } }$ does not see subgoal rewards and is trained using extrinsic rewards only, it can combine learned skills and primitive actions to discover a flat optimal solution $\\pi ^ { * }$ to the MDP (Barto & Mahadevan, 2003). Indeed, our algorithm allows $\\pi _ { \\mathcal { O } }$ to employ discovered skills to quickly and reliably find feasible paths to the goal, which over time can be refined into optimal solutions. It is worth noting that our ability to recover $\\pi ^ { * }$ in the limit is in contrast to feudal methods such as HAC (Levy et al., 2019) in which higher levels of the hierarchy are rewarded for choosing feasible subgoals, not optimal ones. ",
+        "bbox": [
+            174,
+            358,
+            825,
+            498
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To summarize, our algorithm proceeds as follows: (1) Collect trajectories that trigger new option $O _ { k }$ ’s termination condition $\\beta _ { o _ { k } }$ . (2) Train $o _ { k }$ ’s option policy $\\pi _ { o _ { k } }$ . (3) Learn $o _ { k }$ ’s initiation set classifier $\\mathcal { T } _ { o _ { k } }$ . (4) Add $o _ { k }$ to the agent’s option repertoire. (5) Create a new option $O k { + 1 }$ such that $\\beta _ { o _ { k + 1 } } = \\mathcal { T } _ { o _ { k } }$ . (6) Train policy over options $\\pi _ { \\mathcal { O } }$ . Steps 1, 3, 4 and 5 continue until the MDP’s start state is inside some option’s initiation set. Continue steps 2 and 6 indefinitely. ",
+        "bbox": [
+            174,
+            505,
+            825,
+            575
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            597,
+            326,
+            612
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We test our algorithm in five tasks that exhibit a strong hierarchical structure: (1) Point-Maze (Duan et al., 2016), (2) Four Rooms with Lock and Key, (3) Reacher (Brockman et al., 2016), (4) Point E-Maze and (5) Ant-Maze (Duan et al., 2016; Brockman et al., 2016). Since tasks 1, 3 and 5 appear frequently in the literature, details of their setup can be found in Appendix A.3. ",
+        "bbox": [
+            174,
+            627,
+            823,
+            684
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Four Rooms with Lock and Key: In this task, a point agent (Duan et al., 2016) is placed in the Four Rooms environment (Sutton et al., 1999). It must pick up the key (blue sphere in the top-right room in Figure 1(c), row 2) and then navigate to the lock (red sphere in the top-left room). The agent’s state space consists of its position, orientation, linear velocity, rotational velocity and a has key indicator variable. If it reaches the lock with the key in its possession, its episode terminates with a sparse reward of 0; otherwise it gets a step penalty of $- 1$ . If we wish to autonomously discover the importance of the key, (i.e, without any corresponding extrinsic rewards) a distance-based dense reward such as that used in related work (Nachum et al., 2018) would be infeasible. ",
+        "bbox": [
+            174,
+            690,
+            825,
+            801
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Point E-Maze: This task extends the benchmark U-shaped Point-Maze task (Duan et al., 2016) so that the agent has two possible start locations - on the top and bottom rungs of the E-shaped maze respectively. We include this task to demonstrate our algorithm’s ability to construct skill trees. ",
+        "bbox": [
+            174,
+            809,
+            825,
+            852
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 COMPARATIVE ANALYSES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            397,
+            882
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We compared the performance of our algorithm to DDPG, Option-Critic and Hierarchical ActorCritic (HAC), in the conditions most similar to those in which they were originally evaluated. For instance, in the Ant-Maze task we compare against Option-Critic under a dense-reward formulation of the problem while comparing to HAC under a sparse-reward version of the same task. As a result, we show the learning curves comparing against them on different plots (columns (a) and (b) in Figure 1 respectively) to emphasize the difference between the algorithms, the settings in which they are applicable, and the way they are evaluated. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/697848785d9ab3077051b3a746a3382783f1c3bab8db438fbfb212c44bb9afcc.jpg",
+        "image_caption": [
+            "Figure 1: (a) Learning curves comparing deep skill chaining (DSC), a flat agent (DDPG) and OptionCritic. (b) Comparison with Hierarchical Actor Critic (HAC). (c) the continuous control tasks corresponding to the learning curves in (a) and (b). Solid lines represent median reward per episode, with error bands denoting one standard deviation. Our algorithm remains the same between (a) and (b). All curves are averaged over 20 runs, except for Ant Maze which was averaged over 5 runs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            79,
+            828,
+            858
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/5abee1d28fc428024ed73b0642786995a25bd95477a49cacef860deb0bdb465a.jpg",
+        "image_caption": [
+            "Figure 2: Initiation sets of options learned in the Lock and Key task. Blue sphere in top-right room represents the key, red sphere in top-left room represents the lock. Red regions represent states inside the initiation classifier of learned skills, whereas blue/gray regions represent states outside of it. Each column represents an option - the top row corresponding to the initiation set when has key is false and the bottom row corresponding to the initiation set when has key is true. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            75,
+            826,
+            292
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            396,
+            825,
+            467
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Comparison with DDPG and Option-Critic: Figure 1(a) shows the results of comparing our proposed algorithm (DSC) with a flat RL agent (DDPG) and the version of Option-Critic designed for continuous action spaces (PPOC).4 Deep skill chaining comfortably outperforms both baselines. Both DSC and DDPG use the same exploration strategy in which $a _ { t } \\doteq \\pi _ { \\theta } ( s _ { t } ) + \\eta _ { t }$ where $\\eta _ { t } \\sim N ( 0 , \\epsilon _ { t } )$ . Option-Critic, on the other hand, learns a stochastic policy $\\pi _ { \\boldsymbol { \\theta } } \\big ( a _ { t } | \\boldsymbol { s } _ { t } \\big )$ and thus has baked-in exploration (Sutton & Barto, 2018, Ch. 13), precluding the need for additive noise during action selection. We hypothesize that this difference in exploration strategies is the reason OptionCritic initially performs better than both DDPG and DSC in the Reacher and Point E-Maze tasks. ",
+        "bbox": [
+            173,
+            473,
+            825,
+            584
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Comparison with Hierarchical Actor-Critic: We compare our algorithm to Hierarchical ActorCritic (HAC) (Levy et al., 2019), which has recently outperformed other hierarchical reinforcement learning methods (Nachum et al., 2018; Vezhnevets et al., 2017) on a wide variety of tasks. $^ { 5 } \\mathrm { ~ \\bf ~ A ~ }$ noteworthy property of the HAC agent is that it may prematurely terminate its training episodes to prevent flooding its replay buffer with uninformative transitions. The length of each training episode in DSC however, is fixed and determined by the test environment. Unless the agent reaches the goal state, its episode lasts for the entirety of its episodic budget (e.g, this would be 1000 timesteps in the Point-Maze environment). Thus, to compare the two algorithms, we perform periodic test rollouts wherein all networks are frozen and both algorithms have the same time budget to solve the given task. Furthermore, since both DSC and HAC learn deterministic policies, we set $\\epsilon _ { t } = 0$ during these test rollouts. When comparing to HAC, we perform 1 test rollout after each training episode in all tasks except for Ant-Maze, where we average performance over 5 test rollouts every 10 episodes. ",
+        "bbox": [
+            173,
+            592,
+            825,
+            758
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 1(b) shows that DSC outperforms HAC in all environments except for Four Rooms with a Lock and Key, where their performance is similar, even though DSC does not use Hindsight Experience Replay (Andrychowicz et al., 2017) to deal with the sparse reward nature of this task. ",
+        "bbox": [
+            176,
+            765,
+            823,
+            808
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 INTERPRETING LEARNED SKILLS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            827,
+            446,
+            840
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 visualizes the initiation set classifiers of options discovered by DSC in Four Rooms with a Lock and Key. Despite not getting any extrinsic reward for picking up the key, DSC discovers the following skill chain: the options shown in Figure 2 columns (c) and (d) bring the agent to the room with the key. The option shown in column (b) then picks up the key (top row) and then takes the agent to the room with the lock (bottom row). Finally, the option in column (a) solves the overall problem by navigating to the lock with the key. Similar visualizations of learned initiation set classifiers in the E-Maze task can be found in the Figure 6 in the Appendix. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            882
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/408f4247f050f9527a062e4cf18e13ce9058efa8964d789d24987a6b3b65a070.jpg",
+        "image_caption": [
+            "Figure 3: Solution trajectories found by deep skill chaining. Sub-figure (d) shows two trajectories corresponding to the two possible initial locations in this task. Black points denote states in which $\\pi _ { \\mathcal { O } }$ chose primitive actions, other colors denote temporally extended option executions. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            220,
+            75,
+            785,
+            179
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            247,
+            825,
+            318
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 shows that DSC is able to learn options that induce simple, efficient policies along different segments of the state-space. Furthermore, it illustrates that in some states, the policy over options prefers primitive actions (shown in black) over learned skills. This suggests that DSC is robust to situations in which it constructs poor options or is unable to learn a good option policy in certain portions of the state-space. In particular, Figure 3 (d) shows how DSC constructs a skill tree to solve a problem with two distinct start states. It learns a common option near the goal (shown in blue), which then branches off into two different chains leading to its two different start states respectively. ",
+        "bbox": [
+            174,
+            324,
+            825,
+            422
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 DISCUSSION AND CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            444,
+            468,
+            460
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Deep skill chaining breaks complex long-horizon problems into a series of sub-problems and learns policies that solve those sub-problems. By doing so, it provides a significant performance boost when compared to a flat learning agent in all of the tasks considered in Section 4. ",
+        "bbox": [
+            176,
+            477,
+            821,
+            520
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We show superior performance when compared to Option-Critic, the leading framework for option discovery in continuous domains. A significant drawback of Option-Critic is that it assumes that all options are executable from everywhere in the state-space. By contrast, deep skill chaining explicitly learns initiation set classifiers. As a result, learned skills specialize in different regions of the statespace and do not have to bear the burden of learning representations for states that lie far outside of their initiation region. Furthermore, each option in the Option-Critic architecture leverages the same state-abstraction to learn option-specific value functions and policies, while deep skill chaining permits each skill to construct its own skill-specific state-abstraction (Konidaris & Barto, 2009a). An advantage of using Option-Critic over DSC is that it is not confined to goal-oriented tasks and can work in tasks which require continually maximizing non-sparse rewards. ",
+        "bbox": [
+            174,
+            526,
+            825,
+            666
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Section 4 also shows that deep skill chaining outperforms HAC in four out of five domains, while achieving comparable performance in one. We note that even though HAC was designed to work in the multi-goal setting, we test it here in the more constrained single-goal setting. Consequently, we argue that in problems which permit a stationary set of target events (like the ones considered here), deep skill chaining provides a favorable alternative to HAC. Furthermore, HAC depends on Hindsight Experience Replay (HER) to train the different layers of their hierarchy. Deep skill chaining shows the benefits of using hierarchies even in the absence of such data augmentation techniques but including them should yield additional performance benefits in sparse-reward tasks. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            784
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "A drawback of deep skill chaining is that, because it builds skills backward from the goal, its performance in large state-spaces is dependent on a good exploration algorithm. We used the naive exploration strategy of adding Gaussian noise to chosen actions (Lillicrap et al., 2015; Fujimoto et al., 2018) since the exploration question is orthogonal to the ideas presented here. The lack of a sophisticated exploration algorithm also explains the higher variance in performance in the PointMaze task in Figure 1. Combining effective exploration (Machado et al., 2018; Jinnai et al., 2020) with DSC’s high reliability of triggering target events is a promising avenue for future work. ",
+        "bbox": [
+            174,
+            791,
+            823,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We presented a new skill discovery algorithm that can solve high-dimensional goal-oriented tasks far more reliably than flat RL agents and other popular hierarchical methods. To our knowledge, ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "DSC is the first deep option discovery algorithm that does not treat the number of options as a fixed and costly hyperparameter. Furthermore, where other deep option discovery techniques have struggled to show consistent improvements over baseline flat agents in the single task setting (Zhang & Whiteson, 2019; Smith et al., 2018; Harb et al., 2018; Klissarov et al., 2017), we unequivocally show the necessity for hierarchies for solving challenging problems. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            194,
+            398,
+            209
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We thank Andrew Levy, Nakul Gopalan, Sam Lobel, Theresa Barton and other members of the Brown bigAI group for their inputs. This research was supported in part by DARPA under agreement number W911NF1820268, AFOSR Young Investigator Grant agreement number FA9550-17- 1-0124 and the ONR under the PERISCOPE MURI Contract N00014-17-1-2699. The U.S. Government is authorized to reproduce and distribute reprints for Governmental purposes notwithstanding any copyright notation thereon. The content is solely the responsibility of the authors and does not necessarily represent the official views of DARPA, the ONR, or the AFOSR. ",
+        "bbox": [
+            174,
+            224,
+            825,
+            321
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            343,
+            285,
+            358
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marcin Andrychowicz, Filip Wolski, Alex Ray, Jonas Schneider, Rachel Fong, Peter Welinder, Bob McGrew, Josh Tobin, OpenAI Pieter Abbeel, and Wojciech Zaremba. Hindsight experience replay. In Advances in Neural Information Processing Systems, pp. 5048–5058, 2017.   \nPierre-Luc Bacon, Jean Harb, and Doina Precup. The option-critic architecture. In Thirty-First AAAI Conference on Artificial Intelligence, 2017.   \nBram Bakker and Jurgen Schmidhuber. Hierarchical reinforcement learning with subpolicies spe- ¨ cializing for learned subgoals. In Neural Networks and Computational Intelligence, pp. 125–130. Citeseer, 2004.   \nAndrew G Barto and Sridhar Mahadevan. Recent advances in hierarchical reinforcement learning. Discrete event dynamic systems, 13(1-2):41–77, 2003.   \nMarc Bellemare, Sriram Srinivasan, Georg Ostrovski, Tom Schaul, David Saxton, and Remi Munos. Unifying count-based exploration and intrinsic motivation. In Advances in Neural Information Processing Systems, pp. 1471–1479, 2016.   \nSteven J Bradtke and Michael O Duff. Reinforcement learning methods for continuous-time markov decision problems. In Advances in neural information processing systems, pp. 393–400, 1995.   \nRonen I Brafman and Moshe Tennenholtz. R-Max - a general polynomial time algorithm for nearoptimal reinforcement learning. Journal of Machine Learning Research, 3(Oct):213–231, 2002.   \nGreg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym. arXiv preprint arXiv:1606.01540, 2016.   \nYuri Burda, Harrison Edwards, Amos Storkey, and Oleg Klimov. Exploration by random network distillation. In International Conference on Learning Representations, 2019. URL https: //openreview.net/forum?id ${ . } = { }$ H1lJJnR5Ym.   \nPeter Dayan and Geoffrey E Hinton. Feudal reinforcement learning. In Advances in neural information processing systems, pp. 271–278, 1993.   \nThomas G Dietterich. Hierarchical reinforcement learning with the maxq value function decomposition. Journal of Artificial Intelligence Research, 13:227–303, 2000.   \nYan Duan, Xi Chen, Rein Houthooft, John Schulman, and Pieter Abbeel. Benchmarking deep reinforcement learning for continuous control. In International Conference on Machine Learning, pp. 1329–1338, 2016.   \nCarlos Florensa, David Held, Markus Wulfmeier, Michael Zhang, and Pieter Abbeel. Reverse curriculum generation for reinforcement learning. In Conference on Robot Learning, pp. 482–495, 2017. ",
+        "bbox": [
+            171,
+            356,
+            826,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Anthony G Francis and Ashwin Ram. The utility problem in case-based reasoning. In Case-Based Reasoning: Papers from the 1993 Workshop, pp. 160–161, 1993. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Scott Fujimoto, Herke Hoof, and David Meger. Addressing function approximation error in actorcritic methods. In International Conference on Machine Learning, pp. 1582–1591, 2018. ",
+        "bbox": [
+            173,
+            140,
+            821,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jean Harb, Pierre-Luc Bacon, Martin Klissarov, and Doina Precup. When waiting is not an option: Learning options with a deliberation cost. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018. ",
+        "bbox": [
+            174,
+            178,
+            821,
+            220
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Arushi Jain, Khimya Khetarpal, and Doina Precup. Safe option-critic: Learning safety in the optioncritic architecture. CoRR, abs/1807.08060, 2018. URL http://arxiv.org/abs/1807. 08060. ",
+        "bbox": [
+            173,
+            229,
+            821,
+            272
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Steven James, Benjamin Rosman, and George Konidaris. Learning to plan with portable symbols. the ICML/IJCAI/AAMAS 2018 Workshop on Planning and Learning, 2018. ",
+        "bbox": [
+            174,
+            281,
+            820,
+            310
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yuu Jinnai, David Abel, David Hershkowitz, Michael Littman, and George Konidaris. Finding options that minimize planning time. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pp. 3120–3129, Long Beach, California, USA, 09–15 Jun 2019. PMLR. URL http://proceedings.mlr.press/v97/jinnai19a.html. ",
+        "bbox": [
+            174,
+            319,
+            825,
+            390
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yuu Jinnai, Jee Won Park, Marlos C. Machado, and George Konidaris. Exploration in reinforcement learning with deep covering options. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id ${ . } = { }$ SkeIyaVtwB. ",
+        "bbox": [
+            174,
+            398,
+            825,
+            441
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Leslie Pack Kaelbling and Tomas Lozano-P ´ erez. Pre-image backchaining in belief space for mobile ´ manipulation. In Robotics Research, pp. 383–400. Springer, 2017. ",
+        "bbox": [
+            173,
+            449,
+            821,
+            479
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Martin Klissarov, Pierre-Luc Bacon, Jean Harb, and Doina Precup. Learnings options end-to-end for continuous action tasks. Hierarchical Reinforcement Learning Workshop (NeurIPS), 2017. ",
+        "bbox": [
+            173,
+            487,
+            823,
+            517
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "George Konidaris. Constructing abstraction hierarchies using a skill-symbol loop. In IJCAI: proceedings of the conference, volume 2016, pp. 1648. NIH Public Access, 2016. ",
+        "bbox": [
+            173,
+            525,
+            821,
+            554
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "George Konidaris. On the necessity of abstraction. Current Opinion in Behavioral Sciences, 29: 1–7, 2019. ",
+        "bbox": [
+            174,
+            563,
+            820,
+            592
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "George Konidaris and Andrew Barto. Efficient skill learning using abstraction selection. In TwentyFirst International Joint Conference on Artificial Intelligence, 2009a. ",
+        "bbox": [
+            173,
+            599,
+            823,
+            630
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "George Konidaris and Andrew Barto. Skill discovery in continuous reinforcement learning domains using skill chaining. In Advances in Neural Information Processing Systems, pp. 1015–1023, 2009b. ",
+        "bbox": [
+            174,
+            637,
+            823,
+            680
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "George Konidaris, Scott Kuindersma, Roderic Grupen, and Andrew Barto. Robot learning from demonstration by constructing skill trees. The International Journal of Robotics Research, 31(3): 360–375, 2012. ",
+        "bbox": [
+            173,
+            689,
+            823,
+            732
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "George Konidaris, Leslie Pack Kaelbling, and Tomas Lozano-Perez. From skills to symbols: Learning symbolic representations for abstract high-level planning. Journal of Artificial Intelligence Research, 61:215–289, 2018. ",
+        "bbox": [
+            173,
+            739,
+            823,
+            784
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Visak CV Kumar, Sehoon Ha, and C Karen Liu. Expanding motor skills using relay networks. In Conference on Robot Learning, pp. 744–756, 2018. ",
+        "bbox": [
+            169,
+            791,
+            825,
+            821
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew Levy, Robert Platt, and Kate Saenko. Hierarchical reinforcement learning with hindsight. In International Conference on Learning Representations, 2019. URL https://openreview. net/forum?id ${ . } = { }$ ryzECoAcY7. ",
+        "bbox": [
+            174,
+            829,
+            821,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Long-Ji Lin. Reinforcement learning for robots using neural networks. Technical report, CarnegieMellon Univ Pittsburgh PA School of Computer Science, 1993. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Miao Liu, Marlos C Machado, Gerald Tesauro, and Murray Campbell. The eigenoption-critic framework. arXiv preprint arXiv:1712.04065, 2017. ",
+        "bbox": [
+            171,
+            141,
+            821,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Marlos C. Machado, Clemens Rosenbaum, Xiaoxiao Guo, Miao Liu, Gerald Tesauro, and Murray Campbell. Eigenoption discovery through the deep successor representation. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum? id $=$ Bk8ZcAxR-. ",
+        "bbox": [
+            173,
+            179,
+            826,
+            236
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Amy McGovern and Richard S Sutton. Macro-actions in reinforcement learning: An empirical analysis. Computer Science Department Faculty Publication Series, pp. 15, 1998. ",
+        "bbox": [
+            171,
+            244,
+            821,
+            275
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529, 2015. ",
+        "bbox": [
+            174,
+            284,
+            823,
+            327
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ofir Nachum, Shixiang Shane Gu, Honglak Lee, and Sergey Levine. Data-efficient hierarchical reinforcement learning. In Advances in Neural Information Processing Systems, pp. 3303–3313, 2018. ",
+        "bbox": [
+            174,
+            335,
+            825,
+            378
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Scott Niekum and Andrew G. Barto. Clustering via dirichlet process mixture models for portable skill discovery. In J. Shawe-Taylor, R. S. Zemel, P. L. Bartlett, F. Pereira, and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems 24, pp. 1818–1826. Curran Associates, Inc., 2011. ",
+        "bbox": [
+            174,
+            387,
+            825,
+            444
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "F. Pedregosa, G. Varoquaux, A. Gramfort, V. Michel, B. Thirion, O. Grisel, M. Blondel, P. Prettenhofer, R. Weiss, V. Dubourg, J. Vanderplas, A. Passos, D. Cournapeau, M. Brucher, M. Perrot, and E. Duchesnay. Scikit-learn: Machine learning in Python. Journal of Machine Learning Research, 12:2825–2830, 2011. ",
+        "bbox": [
+            173,
+            454,
+            825,
+            511
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Marc Pickett and Andrew G Barto. Policyblocks: An algorithm for creating useful macro-actions in reinforcement learning. In ICML, volume 19, pp. 506–513, 2002. ",
+        "bbox": [
+            173,
+            520,
+            823,
+            549
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matthew Riemer, Miao Liu, and Gerald Tesauro. Learning abstract options. In Advances in Neural Information Processing Systems, pp. 10424–10434, 2018. ",
+        "bbox": [
+            173,
+            558,
+            821,
+            588
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tom Schaul, Daniel Horgan, Karol Gregor, and David Silver. Universal value function approximators. In International conference on machine learning, pp. 1312–1320, 2015. ",
+        "bbox": [
+            173,
+            595,
+            821,
+            626
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jurgen Schmidhuber. Learning to generate sub-goals for action sequences. In ¨ Artificial neural networks, pp. 967–972, 1991. ",
+        "bbox": [
+            173,
+            635,
+            823,
+            664
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Archit Sharma, Shixiang Gu, Sergey Levine, Vikash Kumar, and Karol Hausman. Dynamics-aware unsupervised discovery of skills. arXiv preprint arXiv:1907.01657, 2019. ",
+        "bbox": [
+            173,
+            672,
+            823,
+            702
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Silver and Kamil Ciosek. Compositional planning using optimal option models. In ICML, 2012. ",
+        "bbox": [
+            173,
+            710,
+            823,
+            739
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ozg ¨ ur S¸ ims¸ek and Andrew G Barto. Using relative novelty to identify useful temporal abstractions ¨ in reinforcement learning. In Proceedings of the twenty-first international conference on Machine learning, pp. 95. ACM, 2004. ",
+        "bbox": [
+            174,
+            748,
+            825,
+            791
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ozg ¨ ur S¸ ims¸ek, Alicia P Wolfe, and Andrew G Barto. Identifying useful subgoals in reinforcement ¨ learning by local graph partitioning. In Proceedings of the 22nd international conference on Machine learning, pp. 816–823. ACM, 2005. ",
+        "bbox": [
+            174,
+            801,
+            821,
+            844
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matthew Smith, Herke van Hoof, and Joelle Pineau. An inference-based policy gradient method for learning options. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 4703–4712, Stockholmsmassan, Stockholm Sweden, 10–15 Jul 2018. PMLR. URL ¨ http: //proceedings.mlr.press/v80/smith18a.html. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT press, 2018. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton, Doina Precup, and Satinder P Singh. Intra-option learning about temporally abstract actions. In ICML, volume 98, pp. 556–564, 1998. ",
+        "bbox": [
+            169,
+            127,
+            821,
+            156
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton, Joseph Modayil, Michael Delp, Thomas Degris, Patrick M Pilarski, Adam White, and Doina Precup. Horde: A scalable real-time architecture for learning knowledge from unsupervised sensorimotor interaction. In The 10th International Conference on Autonomous Agents and Multiagent Systems-Volume 2, pp. 761–768. International Foundation for Autonomous Agents and Multiagent Systems, 2011. ",
+        "bbox": [
+            173,
+            165,
+            825,
+            234
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "R.S. Sutton, , D. Precup, and S. Singh. Between MDPs and semi-MDPs: A framework for temporal abstraction in reinforcement learning. Artificial Intelligence, 112(1):181–211, 1999. ",
+        "bbox": [
+            173,
+            244,
+            823,
+            273
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Haoran Tang, Rein Houthooft, Davis Foote, Adam Stooke, OpenAI Xi Chen, Yan Duan, John Schulman, Filip DeTurck, and Pieter Abbeel. # exploration: A study of count-based exploration for deep reinforcement learning. In Advances in neural information processing systems, pp. 2753– 2762, 2017. ",
+        "bbox": [
+            174,
+            281,
+            825,
+            338
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Russ Tedrake. LQR-trees: Feedback motion planning on sparse randomized trees. 2009. ",
+        "bbox": [
+            169,
+            347,
+            754,
+            363
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Gerald Tesauro. TD-Gammon, a self-teaching backgammon program, achieves master-level play. Neural computation, 6(2):215–219, 1994. ",
+        "bbox": [
+            174,
+            371,
+            825,
+            400
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Saket Tiwari and Philip S Thomas. Natural option critic. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 5175–5182, 2019. ",
+        "bbox": [
+            173,
+            409,
+            821,
+            438
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In 2012 IEEE/RSJ International Conference on Intelligent Robots and Systems, pp. 5026–5033. IEEE, 2012. ",
+        "bbox": [
+            173,
+            446,
+            825,
+            488
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hado Van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double Qlearning. In Thirtieth AAAI Conference on Artificial Intelligence, 2016. ",
+        "bbox": [
+            173,
+            498,
+            823,
+            527
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alexander Sasha Vezhnevets, Simon Osindero, Tom Schaul, Nicolas Heess, Max Jaderberg, David Silver, and Koray Kavukcuoglu. Feudal networks for hierarchical reinforcement learning. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 3540– 3549. JMLR. org, 2017. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            593
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christopher JCH Watkins and Peter Dayan. Q-learning. Machine learning, 8(3-4):279–292, 1992. ",
+        "bbox": [
+            171,
+            601,
+            816,
+            617
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shangtong Zhang and Shimon Whiteson. DAC: The double actor-critic architecture for learning options. In Advances in neural information processing systems, pp. To appear, 2019. URL https://arxiv.org/abs/1904.12691. ",
+        "bbox": [
+            178,
+            626,
+            820,
+            667
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/a31fe876124f6b27d5b272d4ef15b760805230e8aa0bc8f3fa175cb28f3d9f21.jpg",
+        "image_caption": [
+            "Figure 4: An illustration of the deep skill chaining algorithm. $\\star$ represents the goal state, $\\times$ represents the two start states. (a) Before the agent has discovered its first skill/option, it acts according to its global DDPG policy. Having encountered the goal state $N$ times, the agent creates an option to trigger the goal from its local neighborhood. (b) Now, when the agent enters the initiation set of the first option, it begins to learn another option to trigger the first option. (c) Because the agent has two different start states, it learns two qualitatively different options to trigger the option learned in (b). (d) Finally, the agent has learned a skill tree which it can follow to consistently reach the goal. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            108,
+            794,
+            280
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            417,
+            297,
+            433
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.1 CREATING SKILL TREES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            448,
+            388,
+            462
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In Section 3.4, we introduced the idea of generalizing skill chains to skill trees to incorporate qualitatively different solution trajectories. In this section, we provide some of the implementation details required to learn initiation set classifiers that organize in the form of trees. ",
+        "bbox": [
+            174,
+            473,
+            823,
+            516
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "When creating skill chains, the goal of each option is to trigger the initiation condition of the option that precedes it in its chain (i.e, its parent option). When creating a skill tree of branching factor $B$ , we allow at most $B$ options to target each salient event in the MDP (i.e, the goal state and the initiation set classifiers of preexisting options). To further control the branching factor of the skill tree, we impose two more conditions on option creation: ",
+        "bbox": [
+            174,
+            522,
+            825,
+            593
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. Consider an option $o _ { 1 }$ which already has one child option $o _ { 2 }$ targeting it. Now suppose that we want to learn another option $o _ { 3 }$ that also targets $o _ { 1 }$ . We only consider state $s _ { t }$ to be a positive example for training $\\mathcal { T } _ { o _ { 3 } }$ if $\\mathcal { T } _ { o _ { 2 } } ( s _ { t } ) = 0$ . 2. To prevent significant overlap between options that target the same event, we treat the positive examples used to train the initiation set classifier of one as negative training examples of all its sibling options. This allows for multiple options that trigger the same target event, while encouraging them to specialize in different parts of the state-space. ",
+        "bbox": [
+            212,
+            604,
+            825,
+            708
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In the Point E-Maze task considered in Section 4, we learn a skill tree with $B = 2$ ",
+        "bbox": [
+            174,
+            719,
+            712,
+            734
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.2 INTRA-OPTION Q-LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            751,
+            419,
+            765
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In principle, the methodology outlined in Section 3.2 is sufficient to learn an effective policy over options $\\pi _ { \\mathcal { O } }$ . However, when $\\mathcal { O }$ is a set of Markov options (Sutton et al., 1999), which is the setting considered in this paper, we can use intra-option Q-learning (Sutton et al., 1998) to improve the sample efficiency associated with learning $\\pi _ { \\mathcal { O } }$ . ",
+        "bbox": [
+            174,
+            776,
+            825,
+            833
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "More specifically, given a transition $( s _ { t } , o , r _ { t : t + \\tau } , s _ { t + \\tau } )$ , SMDP Q-learning treats option $o$ as a black box and uses Equation 4 to determine the Q-value target $y _ { t }$ for updating $\\pi _ { \\mathcal { O } }$ . Intra-option Q-learning leverages the fact that option $o$ is Markov to point out that all the transitions experienced during the execution of $o$ are also valid experiences for training $\\pi _ { \\mathcal { O } }$ . As long as a state $s _ { t + i } , \\forall i \\in [ 0 , \\tau ]$ is inside the initiation set of the option $o$ , we can pretend that option execution really began in state $s _ { t + i }$ and add the transition $( s _ { t + i } , o , r _ { t + i : t + \\tau } , s _ { t + \\tau } )$ to the $\\pi _ { \\mathcal { O } }$ ’s replay buffer. ",
+        "bbox": [
+            174,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, intra-option Q-learning also provides a way to improve the sample efficiency associated with learning option policies $\\pi _ { o } , \\forall o \\in { \\mathcal { O } }$ . This can be done by making off-policy updates to each option’s internal policy. In other words, regardless of which option is actually executed in the MDP, as long as a state experienced during execution is inside the initiation set of some other option, we can add the associated experience tuple to that (un-executed) option’s replay buffer. Note that this is possible because we use an off-policy learning algorithm (DDPG) to learn intra-option policies. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.3 TEST ENVIRONMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            218,
+            372,
+            232
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A description of the Four Rooms and the Point E-Maze tasks was provided in Section 4. Here we describe the remaining tasks considered in this paper: ",
+        "bbox": [
+            174,
+            243,
+            823,
+            272
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Point Maze: In this task, the same point agent as in the four rooms task must navigate around a U-shaped maze to reach its goal. The agent receives a reward of $- 1$ for every step it lives, and a sparse terminating reward of 0 when it reaches its goal location. This is an interesting task for hierarchical agents because in order to reach the goal, the agent must first move away from it. It is clear that a dense distance-based reward formulation of this problem would only serve to deceive non-hierarchical agents such as DDPG. ",
+        "bbox": [
+            174,
+            279,
+            825,
+            363
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Ant Maze: The ant (Duan et al., 2016) is a challenging agent to control due to its non-linear and highly unstable dynamics. In this task, the ant must now navigate around the same U-shaped maze as in the Point Maze task. Getting the ant to cover significant distances along the $x , y$ plane without falling over, is a benchmark control task itself (Brockman et al., 2016). As a result, constructing options backward from the goal could require prohibitively large training episodes or the use of a sophisticated exploration algorithms (Burda et al., 2019; Bellemare et al., 2016; Tang et al., 2017). To avoid conflating our results with the orthogonal investigation of effective exploration in RL, we follow the experimental design of other state-of-the-art hierarchical reinforcement learning algorithms (Levy et al., 2019; Nachum et al., 2018) and sample the initial state of the ant uniformly across the maze for the first 30 episodes. For fair comparison, all baseline algorithms use this exploration strategy. ",
+        "bbox": [
+            174,
+            369,
+            825,
+            523
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Fixed Reacher: We use the Reacher task (Brockman et al., 2016) with two modifications. First, rather than randomly sampling a new goal at the start of each episode, we fix the target across all episodes. We do this because if the goal moves, following a learned skill chain will no longer solve the MDP. Note that the same modification was made in the DDPG paper (Lillicrap et al., 2015). Second, to increase the difficulty of the resulting task, we use a sparse reward function rather than the dense distance-based one used in the original formulation. ",
+        "bbox": [
+            174,
+            529,
+            823,
+            614
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/d2f65fb18509726a90a70b0d807be3bf538e717f4978915545bc832f84a3bdd0.jpg",
+        "table_caption": [
+            "Table 1: Maximum number of time steps per episode in each of the experimental domains "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Task</td><td>Number of steps per episode</td></tr><tr><td>Point-Maze</td><td>1000</td></tr><tr><td>Four Rooms with Lock and Key</td><td>5000</td></tr><tr><td>Point E-Maze</td><td>1500</td></tr><tr><td>Reacher</td><td>500</td></tr><tr><td>Ant-Maze</td><td>2000</td></tr></table>",
+        "bbox": [
+            272,
+            627,
+            725,
+            727
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/b5fd9a8aeadb9b741a2285df1519103a27534cbc81265ce00e546732b369bbab.jpg",
+        "image_caption": [
+            "Figure 5: Analysis of performance (as measured by mean cumulative reward) of DSC agent as it is allowed to learn more skills in (a) Point-Maze, (b) Four Rooms with Lock and Key, (c) E-Maze and (d) Ant-Maze. Note that in general, DSC discovers as many skills as it needs to solve the given problem. For this experiment alone, we restrict the number of skills that the DSC agent can learn. All experiments averaged over 5 runs. Error bars denote 1 standard deviation. Higher is better. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            160,
+            159,
+            833,
+            284
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/ecd37dd6134140018731ede6dff36800431561434531484a2551f96d47a907d5.jpg",
+        "image_caption": [
+            "Figure 6: Initiation set classifiers learned in the Point E-Maze domain. Discovered skills organize in the form of a tree with a branching factor of 2. The option on the extreme left initiates in the proximity of the goal. Options learned after the goal option branch off into two separate skill chains. The chain on top extends backward to the start state in the top rung of the E-Maze. The chain shown in the bottom row extends backward to the start state in the bottom rung of the E-Maze. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            483,
+            831,
+            767
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.4 ABLATION STUDY ",
+        "bbox": [
+            176,
+            103,
+            346,
+            118
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "A.4.1 PERFORMANCE AS A FUNCTION OF NUMBER OF SKILLS ",
+        "bbox": [
+            173,
+            185,
+            620,
+            200
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Deep skill chaining generally discovers and learns as many skills as it needs to solve a given problem. In this experiment however, we restrict the number of skills DSC can learn to examine its impact on overall agent performance (as measured by cumulative reward during training). Figure 5 shows that the performance of the agent increases monotonically (with diminishing marginal improvements) as it is allowed to learn more skills. ",
+        "bbox": [
+            174,
+            266,
+            825,
+            337
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "A.4.2 NUMBER OF SKILLS OVER TIME ",
+        "bbox": [
+            176,
+            493,
+            455,
+            508
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Figures 7 (a) and 7 (b) illustrate how deep skill chaining incrementally discovers options and adds it to the agent’s option repertoire. Figure 7(c) shows how the number of skills empirically increases over time, plateaus and has low variance between runs. Since the agent has to learn the importance of the key in the Four Rooms task, learning initiation set classifiers takes longer than in the Point-Maze task. ",
+        "bbox": [
+            173,
+            574,
+            825,
+            643
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "A.4.3 HYPERPARAMETER SENSITIVITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            800,
+            460,
+            815
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "In this section, we analyze DSC’s sensitivity to some of the hyperparameters specific to the algorithm. In Figure 8, we show that even under a fairly large range of values for the buffer length $K$ and the gestation period $N$ , DSC is able to retain its strong performance. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/c3d2982704132df960ad0ee2003ed8d7eae95a315cd07c5f0d5bd673ebc3ca4d.jpg",
+        "image_caption": [
+            "Figure 7: (a) Initially, the policy over options $\\pi _ { \\mathcal { O } }$ can only choose the global option $o _ { G }$ as a proxy for selecting primitive actions. (b) Over time, the agent learns temporally extended skills and adds output nodes to the final layer of the DQN parameterizing $\\pi _ { \\mathcal { O } }$ . This continues until the start state $s _ { 0 }$ lies inside the initiation set of a learned option. (c) Empirical evaluation of how the number of skills in the agent’s option repertoire changes over time in Point-Maze and Four-Rooms with a Lock and Key. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            258,
+            834,
+            671
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/d956447d8fe51e03b6f46f81b4592ccaea446ed99bd7de7161dc8def31572719.jpg",
+        "image_caption": [
+            "Figure 8: Variation in DSC performance (as measured by mean cumulative reward) as a function of two hyperparameters: (left) the buffer length $K$ and (right) the gestation period $N$ of the option. For a qualitative description of both hyperparameters, refer to Section 3.3. This experiment shows that DSC is fairly robust to most reasonable choices of these parameters. All experiments averaged over 5 runs. Error bars denote 1 standard deviation. Higher is better. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            127,
+            795,
+            400
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "",
+        "text_level": 1,
+        "bbox": [
+            176,
+            133,
+            403,
+            148
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "table",
+        "img_path": "images/70aff6edc41560ce1b263c4fa591fa32ea7e9c8e1204dc8560fec9247a16c0c9.jpg",
+        "table_caption": [
+            "A.5 ALGORITHM PSEUDO-CODE "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm1: Deep Skill Chaining So is the start state of the MDP</td></tr><tr><td>1g(s) := 1 if s is a target state in the MDP, O otherwise</td></tr><tr><td>Given hyperparameter To, the time budget for discovered, temporally extended options Global option: 0G = (Iog,Tog,βoG = 1g,T=1) Goaloption:0g=(Igβog=1g,T=T)</td></tr><tr><td>Agent&#x27;s option repertoire: O={0G}</td></tr><tr><td>Untrained Option: ou = og //option whose initiation classifier is yet unlearned</td></tr><tr><td></td></tr><tr><td>Policy over options: πo: St → 0t</td></tr><tr><td>St = S0</td></tr><tr><td>while not st.is_terminal() do</td></tr><tr><td>1. Pick new option and execute in environment</td></tr><tr><td>Choose Ot according to πo(st） using Equations 2 and 3</td></tr><tr><td>rt:t,St+r = execute_option(Ot)</td></tr><tr><td>TO.update(St, Ot, rt:t+r, St+r) using Equation 4</td></tr><tr><td>2.Learn initiation set of new option</td></tr><tr><td>// Collect trajectories that trigger Ou&#x27;s termination region unless we have finished chaining</td></tr><tr><td>if βou(st+r)&amp;(soeI∀oi ∈O) then ou.learn_initiation_classifier() using procedure described in Section 3.3</td></tr><tr><td>if ou.initiation_classifier_is_trained() then</td></tr><tr><td>T.add(ou） using procedure described in Section 3.2</td></tr><tr><td>O.append(ou)</td></tr><tr><td>Ou = create_child_option(ou)</td></tr><tr><td>end</td></tr><tr><td>end</td></tr><tr><td>end</td></tr><tr><td>Function create_child_option (o) : &quot; Create a new option whose β is the parent&#x27;s I.</td></tr><tr><td>0* = Option() // Create a new option</td></tr><tr><td>Lo* =None</td></tr><tr><td>β*=I</td></tr><tr><td>return 0*</td></tr><tr><td>Function execute_option (ot) :</td></tr><tr><td>&quot;&quot;” Option control loop. ；””</td></tr><tr><td>to=t</td></tr><tr><td>Tis the option&#x27;s episodic time budget</td></tr><tr><td>Tot is the option&#x27;s internal policy</td></tr><tr><td></td></tr><tr><td>while not βot(st)&amp;t&lt;Tdo</td></tr><tr><td>at= Tot(St;0ot）</td></tr><tr><td>Tt, St+1 = env.step(at)</td></tr><tr><td></td></tr><tr><td>St=St+1</td></tr><tr><td>t=t+1</td></tr><tr><td></td></tr><tr><td></td></tr><tr><td>end</td></tr><tr><td></td></tr><tr><td>T=t// duration ofoption execution</td></tr></table>",
+        "bbox": [
+            171,
+            137,
+            794,
+            776
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "A.6 MORE DETAILS ON IMPLEMENTING OPTION REWARD FUNCTIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            791,
+            678,
+            806
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "Section 3.1 explains that to learn an option’s intra-option policy, we must define its internal reward function. While most of our experiments are conducted in the sparse-reward setting, deep skill chaining can be used without much modification in dense reward tasks as well. All that remains is a clear description of how each option’s internal reward function would be defined in such a setting. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            875
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "Consider an option $o _ { i }$ with parent option $o _ { i - 1 }$ such that $\\beta _ { o _ { i } } = \\mathcal { T } _ { o _ { i - 1 } }$ . In the dense reward setting, we use the negative distance from the state to the parent option’s initiation classifier as the reward function. Since initiation classifiers are represented using parametric classifiers, computing the distance to the classifier’s decision boundary is straightforward and can be done using most popular machine learning frameworks. For instance, when using scikit-learn (Pedregosa et al., 2011), this is implemented as follows: ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            826,
+            146
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9174dd10c1cff8613e2d9231678447ce6f55fdc7a4f7fada28ad7a4ba6194426.jpg",
+        "text": "$$\nR _ { o } ( s , a , s ^ { \\prime } ) = \\left\\{ \\begin{array} { l l } { 0 , } & { \\mathrm { i f ~ } \\beta _ { o } ( s ^ { \\prime } ) = 1 } \\\\ { - \\mathscr { T } _ { o _ { i - 1 } . \\mathrm { d e c i s i o n . f u n c t i o n } ( s ^ { \\prime } ) , } } & { \\mathrm { o t h e r w i s e } } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            267,
+            166,
+            728,
+            203
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "Where in Equation 5, decision function $( x )$ returns the distance in feature space between point $\\boldsymbol { x } \\in \\mathbb { R } ^ { \\dot { N } }$ and the decision boundary learned by the classifier $\\mathcal { T } _ { o _ { i - 1 } }$ . ",
+        "bbox": [
+            174,
+            220,
+            825,
+            251
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "A.7 LEARNING INITIATION SET CLASSIFIERS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            268,
+            503,
+            284
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "To learn initiation set classifiers as described in Section 3.3, we used scikit-learn’s One-Class SVM and Two-Class SVM packages (Pedregosa et al., 2011). Initiation set classifiers were learned on a subset of the state variables available in the domain. For instance, in the Lock and Key domain, the initiation set classifier was learned over the $x , y$ position and the has key indicator variable. This is similar to other methods like HAC (Levy et al., 2019) which require the user to specify the dimensions of the state variable necessary to achieve the overall goal of the MDP. Incorporating the entire state variable to learn initiation set classifiers or using neural networks for automatic feature extraction should be straightforward and is left as future work. ",
+        "bbox": [
+            173,
+            296,
+            825,
+            409
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "A.8 HYPERPARAMETER SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            428,
+            426,
+            441
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "We divide the full set of hyperparameters that our algorithm depends on into two groups: those that are common to all algorithms that use DDPG (Table 2), and those that are specific to skill chaining (Table 3). We did not try to optimize over the space of DDPG hyperparameters, and used the ones used in previous work (Lillicrap et al., 2015; Fujimoto et al., 2018). Table 3 shows the hyperparameters that we chose on the different tasks considered in this paper. Most of them are concerned with learning initiation set classifiers, the difficulty of which varies based on domain. To determine the correct setting of these parameters, we usually visualized the learned initiation set classifiers during the course of training (like Figures 2 and 6), and made adjustments accordingly. ",
+        "bbox": [
+            173,
+            454,
+            825,
+            566
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "table",
+        "img_path": "images/7cc86e957c833ee139db604b0bf2a057580bdf4ffaf93da537a98ce9e355b462.jpg",
+        "table_caption": [
+            "Table 2: DDPG Hyperparameters "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Parameter</td><td>Value</td></tr><tr><td>Replay buffer size</td><td>1e6</td></tr><tr><td>Batch size</td><td>64</td></tr><tr><td>Y</td><td>0.99</td></tr><tr><td>T</td><td>0.01</td></tr><tr><td>Number of hidden layers</td><td>2</td></tr><tr><td>Hidden size 1</td><td>400</td></tr><tr><td>Hidden size 2</td><td>300</td></tr><tr><td>Critic learning rate</td><td>1e-3</td></tr><tr><td>Actor learning rate</td><td>le-4</td></tr></table>",
+        "bbox": [
+            372,
+            582,
+            624,
+            736
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "table",
+        "img_path": "images/bab6817636b83c57f6222cb27871afea4b255a0c02116f89e4d6030eb7925f20.jpg",
+        "table_caption": [
+            "Table 3: Deep Skill Chaining Hyperparameters "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Parameter</td><td> Point Maze</td><td>Four Rooms</td><td>Reacher</td><td> Ant Maze</td><td>E-Maze</td></tr><tr><td>Gestation Period (N)</td><td>5</td><td>10</td><td>5</td><td>1</td><td>5</td></tr><tr><td>Initiation Period</td><td>1</td><td>10</td><td>3</td><td>0</td><td>1</td></tr><tr><td>Buffer Length (K)</td><td>20</td><td>20</td><td>20</td><td>750</td><td>20</td></tr><tr><td>Option Max Time Steps (T)</td><td>100</td><td>150</td><td>150</td><td>100</td><td>100</td></tr></table>",
+        "bbox": [
+            171,
+            795,
+            826,
+            880
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "A.9 COMPUTE INFRASTRUCTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            419,
+            117
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "We used 1 NVIDIA GeForce 2080 Ti, 2 NVIDIA GeForce $2 0 7 0 \\mathrm { T i }$ and 2 Tesla K80s on the Google Cloud compute infrastructure to perform all experiments reported in this paper. ",
+        "bbox": [
+            173,
+            128,
+            823,
+            159
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "A.10 NOTE ON COMPUTATION TIME ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            174,
+            441,
+            189
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "Each option is parameterized by its own neural networks, which are only updated when the agent is inside that option’s initiation set. For a given transition, this leads to at most two or three updates. In Point-Maze, updating all options on a transition took $0 . 0 0 4 \\pm 0 . 0 0 0 3$ s more than just updating the global DDPG agent (averaged over 300 episodes using 1 NVIDIA 2080 Ti GPU) - a trivial amount of extra computation time. ",
+        "bbox": [
+            174,
+            200,
+            825,
+            270
+        ],
+        "page_idx": 20
+    }
+]

parse/train/BJl6TjRcY7/BJl6TjRcY7.md

@@ -0,0 +1,339 @@
+# NEURAL PROBABILISTIC MOTOR PRIMITIVES FOR HUMANOID CONTROL
+
+Josh Merel∗, Leonard Hasenclever∗, Alexandre Galashov,   
+Arun Ahuja, Vu Pham, Greg Wayne, Yee Whye Teh, & Nicolas Heess   
+DeepMind   
+London, UK   
+{jsmerel,leonardh,agalashov,arahuja,vuph, gregwayne,ywteh,heess}@google.com
+
+# ABSTRACT
+
+We focus on the problem of learning a single motor module that can flexibly express a range of behaviors for the control of high-dimensional physically simulated humanoids. To do this, we propose a motor architecture that has the general structure of an inverse model with a latent-variable bottleneck. We show that it is possible to train this model entirely offline to compress thousands of expert policies and learn a motor primitive embedding space. The trained neural probabilistic motor primitive system can perform one-shot imitation of whole-body humanoid behaviors, robustly mimicking unseen trajectories. Additionally, we demonstrate that it is also straightforward to train controllers to reuse the learned motor primitive space to solve tasks, and the resulting movements are relatively naturalistic. To support the training of our model, we compare two approaches for offline policy cloning, including an experience efficient method which we call linear feedback policy cloning. We encourage readers to view a supplementary video summarizing our results.
+
+# 1 INTRODUCTION
+
+A broad challenge in machine learning for control and robotics is to produce policies capable of general, flexible, and adaptive behavior of complex, physical bodies. To build policies that can effectively control simulated humanoid bodies, researchers must simultaneously overcome foundational challenges related to high-dimensional control, body balance, and locomotion. Recent progress in deep reinforcement learning has raised hopes that such behaviors can be learned end-to-end with minimal manual intervention. Yet, even though significant progress has been made thanks to better algorithms, training regimes, and computational infrastructure, the resulting behaviors still tend to exhibit significant idiosyncrasies (e.g. Heess et al., 2017; Bansal et al., 2018).
+
+One advantage of working with humanoids in this context is that motion capture data is widely available and can serve to help design controllers that produce apparently humanlike movement. Indeed, recent developments are now allowing for the production of highly specialized expert policies which robustly, albeit narrowly, reproduce single motion capture clips (e.g. Liu et al. (2010); Peng et al. (2018)).
+
+A remaining challenge on the way to truly flexible and general purpose control is to be able to sequence and generalize individual movements or “skills” in a task-directed manner. Achieving this goal requires not just the ability to acquire individual skills in the first place, but also an architecture and associated training procedure that supports representation, recruitment, and composition of a large number of skills.
+
+This paper presents a step in this direction. Specifically, the setting we focus on will be one in which we have a large number of robust experts that perform single skills well and we wish to transfer these skills into a shared policy that can do what each expert does as well as the expert, while also generalizing to unseen behaviors within the distribution of skills. To this end we design a system that performs one-shot imitation as well as permits straightforward reuse (or transfer) of skills. We require our approach to scale to a very large number of individual skills while also keeping manual intervention and oversight to a minimum.
+
+Our primary contribution is the development of a neural network architecture that can represent and generate many motor behaviors, which we refer to as neural probabilistic motor primitives. This architecture is designed to perform one-shot imitation, while learning a dense embedding space of a large number of individual motor skills. Once trained, this module does not just reproduce individual behaviors in the training data, but can sequence and compose these behaviors in a controlled fashion as well as synthesize novel movements consistent with the training data distribution. Empirically, we also find that training controllers to reuse this learned motor primitive module for new tasks generates surprisingly human-like movement and the behavior generated seems to interpolate the space of behaviors well.
+
+In order to facilitate transfer and compression of expert skills at the scale of thousands of behaviors, we wish to avoid closed-loop RL training. We call the general, offline, functional transfer of policy content policy transfer or policy cloning and consider two approaches. The natural baseline approach involves the application of behavioral cloning to data gathered by executing experts many times, with noise, and logging intended expert actions, resembling the approach of Laskey et al. (2017). This works well, as it ensures the student behaves like the expert not only along nominal expert rollouts but also at points arrived at by perturbing the expert. However, this approach may require many rollouts, which can be costly to obtain in many settings. As a more efficient alternative we therefore consider a second solution that operates by comprehensively transferring the functional properties of an expert to a student policy by matching the local noise-feedback properties along one or a small number of representative expert reference trajectories. We call this specific proposal linear feedback policy cloning (LFPC), and we demonstrate that it is competitive with behavioral cloning from many more rollouts in our setting.
+
+# 1.1 BACKGROUND & RELATED WORK
+
+Recent efforts in RL for humanoid control build on a large body of research in robotics and animation. While contemporary results for learning from scratch (Schulman et al., 2015; Heess et al., 2017) can be impressive the behaviors are not consistently human-like. Learning from motion capture (mocap) can provide strong constraints, especially for running (Peng et al., 2017; Merel et al., 2017). Several recent approaches have demonstrated that it is possible to acquire specific behavioral skills, possibly jointly with external RL objectives (Merel et al., 2017; Peng et al., 2018; Liu & Hodgins, 2018). At present, the policies produced tend to be restricted to single skills/behaviors and can require very large quantities of environment interactions, motivating us to seek methods which reuse existing single-skill expert policies.
+
+Knowledge transfer refers to the broad class of approaches which transfer the input-output functional mapping, to some extent or another, from a teacher (or expert) to a student (Hinton et al., 2015; Srinivas & Fleuret, 2018; Furlanello et al., 2018). Distillation connotes the transfer of function from one or more expert systems into a single student system often with the goal of compression or of combining multiple experts qualities (Hinton et al., 2015; Parisotto et al., 2015; Rusu et al., 2015; Teh et al., 2017). Imitation learning is the control-specific term for the production of a student policy from either an expert policy or the behavioral demonstrations of an expert. One basic algorithm is behavioral cloning, which refers to supervised training of the policy from state-action pairs. In the most simple case it only requires examples from the expert. A broader setting is that in which more liberal queries to the expert are permitted; e.g. for the online-imitation setting as in DAGGER (Ross et al., 2011). This setting is often satisfied e.g. if we wish to combine behavior from multiple experts.
+
+One-shot imitation is a concept which means that a trained system, at test time, can watch an example behavior and imitate it, as, for instance, in Duan et al. (2017). More similar to our work is the setting examined by Wang et al. (2017), in which full-body humanoid movements were studied. Compared with this latter work, we will employ an architecture here that encourages imitation of motor details, rather than overall movement type, and we scale our approach to more expert demonstrations. The most similar work also demonstrates large-scale one-shot humanoid tracking and was contemporaneously published (Chentanez et al., 2018); the approach they described involves direct tracking as well as failure recovery, but relative to our work the authors do not consider skill reuse.
+
+The notion of motor primitives is widespread in neuroscience, where there is evidence that lower dimensional control signals can selectively coordinate and blend behaviors produced by spinal circuits (Bizzi et al., 2008), and that the cortex organizes the space of primitive motor behaviors (Graziano, 2006). In our setting, motor primitives refer to the reusable embedding space learned from many related behaviors and the associated context-modulable policy capable of generating sensory-feedback-stabilized motor behavior when executed in an environment. The particular architecture we consider is inspired by the formalization presented in Todorov & Ghahramani (2003), which places a probabilistic latent bottleneck on the sensory-motor mapping.
+
+In the robotics literature, there is a rich line of research into various parameterizations of motion trajectories used for robot control. A class of these are referred to as “movement primitives” (e.g. Schaal et al., 2003), including the “probabilistic movement primitives” of Paraschos et al. (2013) (see also e.g. Neumann et al., 2014). These approaches can be seen as specific implementation choices for a certain notion of motor primitive, which emphasize the parameterization and learning of movement trajectories from repeated demonstrations (Paraschos et al., 2013; Meier & Schaal, 2016), rather than learning the actuation/stabilization element, which is often handled by a prespecified PID controller.
+
+It has previously been recognized that linear-feedback policies can work well around optimal trajectories or limit cycles even for high DoF bodies. These can be obtained by sample-based optimization (e.g. Ding et al. (2015)) or by differential dynamic programming (Morimoto & Atkeson, 2003; Tassa et al., 2012; 2014). For linear-quadratic-Gaussian control (Athans, 1971) or differential dynamic programming (Mayne, 1966; Jacobson & Mayne, 1970), we obtain feedback policies where the feedback terms are computed from the value function, amounting effectively to feedbackstabilized plans. Work by Mordatch et al. (2015) has shown that linear-feedback policies resulting from trajectory optimization can be used to train neural networks. We employ a similar idea to transfer optimal behavior from an existing policy, observing that an optimal policy implicitly reflects the structure of the (local) value landscape and appropriately functions as a feedback controller.
+
+# 2 TRANSFER AND COMPRESSION OF EXPERT BEHAVIORS
+
+In this section, we will first briefly describe the expert policies used in this work (Sec. 2.1). We then describe the Neural Probabilistic Motor Primitive architecture and objective (Sec. 2.2). We then describe two approaches for training the module offline (Sec. 2.3).
+
+# 2.1 OBTAINING EXPERTS FROM MOTION CAPTURE DATA
+
+In order to study how to transfer and consolidate experts, we must be able to generate adequate quantities of expert data. For this work, we use expert policies trained to reproduce motion capture clips. The approach we use for producing experts is detailed more fully in Merel et al. (2018) and largely follows Peng et al. (2018). It yields time-indexed neural network policies that are robust to moderate amounts of action noise (see appendix A for additional details on the training procedure). Some examples of the resulting single-skill time-indexed policies that are obtained from this procedure are
+
+![](images/ed05edca419a26dd84104549cc8c7d14ebd4df72f1b45677f99f84c005c33920.jpg)  
+Figure 1: Examples of representative experts learned from motion capture. From top to bottom, these are “run and dodge”, “cartwheel”, “backflip”, and “twist”. See accompanying video. Note that these four behaviors will be used as representative examples for validation in single-skill transfer experiments.
+
+depicted in Fig. 1. All our experts were trained in MuJoCo environments (Todorov et al., 2012).
+
+![](images/8d1159e1a0b22d68408b930ec7b3e7195347dcbe39ee0df412b234bd8ff5fcbd.jpg)  
+Figure 2: Neural probabilistic motor primitive architecture for one-shot skill deployment. The yellow-highlighted information are available for offline, supervised training. Once the full model has been learned, the decoder can be reused as a policy in other settings.
+
+Data We use the CMU Mocap database1, which contains more than 2000 clips of varying lengths from more than 100 subjects. The motions in this dataset are quite varied, including many clips of walking, turning, running, jumping, dancing, various hand movements, and many more idiosyncratic behaviors. From this, we selected various clips of generic whole-body movements – any clips longer than 6 seconds were cut into smaller pieces yielding approximately 3000, roughly 2-6 second snippets. Just over half of these are generic locomotion such as walking, running, jumping and turning. The rest of the clips mostly contained diverse hand movements while standing. We trained one expert policy per selected snippet, yielding 2707 expert policies in our training set.
+
+# 2.2 NEURAL PROBABILISTIC MOTOR PRIMITIVES
+
+Our goal is to obtain a motor primitive module that can flexibly and robustly deploy, sequence, and interpolate a diverse set of skills from a large database of reference trajectories without any manual alignment or other processing of the raw experts. This requires a representation that does not just reliably encode all behavioral modes but also allows effective indexing of behaviors for recall. To ensure plausible and reliable transitions it is further desirable that the encoding of similar behaviors should be close in some sense in the representation space.
+
+Compression of many expert skills via a latent variable inverse model We achieve this goal by training an autoregressive latent variable model of the state-conditional action sequence which, at training time, is conditioned on short look-ahead snippets of the nominal/reference trajectory (see Fig. 2). This architecture has the general structure of an inverse model, which produces actions based on the current state and a target. The architecture and training scheme are designed for the embedding space to reflect short-term motor behavior. As we demonstrate below, this allows for the selective execution of particular behavioral modes and also admits one-shot imitation via the trajectory encoder.
+
+We use a model with a latent variable $z _ { t }$ at each time step, modelling the state conditional action distribution. The encoder and decoder are distributions $q ( \boldsymbol { z } _ { t } | \boldsymbol { z } _ { t - 1 } , \boldsymbol { x } _ { t } )$ and $\pi ( a _ { t } | \boldsymbol { z } _ { t } , \boldsymbol { s } _ { t } )$ where $s _ { t }$ is the state as in preceding sections and $x _ { t }$ is concatenation of a small number of future states $x _ { t } = [ s _ { t } , . . . , s _ { t + K } ]$ . The encoder and decoder are MLPs with two and three layers, respectively. For architecture and experimental details see appendix B. The generative part of the model is given by:
+
+$$
+p ( a _ { 1 : T } , z _ { 1 : T } | s _ { 1 : T } ) = \prod _ { t = 1 } ^ { T } p _ { z } ( z _ { t } | z _ { t - 1 } ) \pi ( a _ { t } | z _ { t } , s _ { t } ) .
+$$
+
+Temporally nearby trajectory snippets should have a similar representation in the latent space. To implement this intuition, we choose an AR(1) process as a weak prior:
+
+$$
+z _ { t } = \alpha z _ { t - 1 } + \sigma \epsilon , \ \epsilon \sim \mathcal { N } ( 0 , I ) ,
+$$
+
+where $\sigma = \sqrt { 1 - \alpha ^ { 2 } }$ , ensuring that marginally $z _ { t } \sim \mathcal { N } ( 0 , I )$ , and set $\alpha = 0 . 9 5$ in experiments unless otherwise stated. In subsequent efforts, it may be interesting to investigate different values of $\alpha$ and learnable priors.
+
+In order to train this model, we consider the evidence lower bound (ELBO):
+
+$$
+\mathbb { E } _ { q } \left[ \sum _ { t = 1 } ^ { T } \log \pi ( a _ { t } | s _ { t } , z _ { t } ) + \beta \big ( \log p _ { z } ( z _ { t } | z _ { t - 1 } ) - \log q ( z _ { t } | z _ { t - 1 } , x _ { t } ) \big ) \right] ,
+$$
+
+with a $\beta$ parameter to tune the weight of the prior. For $\beta = 1$ this objective forms the well-known variational lower bound to $\log p ( a _ { 1 : T } | s _ { 1 : T } )$ . This objective can be optimized using supervised learning (i.e. behavioral cloning from noisy rollouts) offline.
+
+Note we chose not to condition the encoder on actions, since we are interested in one-shot imitation in settings where actions are unobserved. We experimented with different values of $K$ and obtained similar performance. All the results reported in this paper use $K = 5$ .2
+
+Our architecture effectively implements a conditional information bottleneck between the desired future trajectory $x _ { t }$ and the action $a _ { t }$ given the past latent state $z _ { t - 1 }$ (similar to Alemi et al. (2017)). As discussed above the auto-correlated prior encourages an encoding in which temporally nearby latent states from the same trajectory tend to be close in the latent space, and the information bottleneck more generally encourages a limited dependence on $x _ { t }$ with $z _ { t }$ forming a compressed representation of the future trajectory as required for the action choice.
+
+# 2.3 TRAINING A STUDENT POLICY FROM A SET OF EXAMPLES
+
+When transferring knowledge from an expert policy to a student we would like the student to replicate the expert’s behavior in the full set of states plausibly visited by the expert. In our case, experts trained to reproduce single clips can be conceptualized as nonlinear feedback controllers around a nominal trajectory, and the manifold of states visited by experts can be thought of as a tube around that reference. We require the student to be able to operate successfully in and remain close to this tube even in the face of small perturbations.
+
+Formally, to ensure that the student retains expert robustness, we would like expert actions $\mu _ { E } ( s )$ and student actions $\mu _ { \boldsymbol { \theta } } ( s )$ to be close under a plausible (noisy) expert state distribution $\rho _ { E }$ . A surrogate loss used in imitation learning as well as knowledge transfer is the quadratic loss between actions (Ross et al., 2011) (or activations Srinivas & Fleuret (2018)).
+
+$$
+\operatorname* { m i n } _ { \theta } \mathbb { E } _ { s \sim \rho _ { E } } [ ( \mu _ { E } ( s ) - \mu _ { \theta } ( s ) ) ^ { 2 } ]
+$$
+
+Behavioral cloning can refer to optimization of this objective, where $\rho _ { E }$ is replaced with an empirical distribution of a set of state-action pairs $s$ . This works well if $s$ adequately covers the state distribution later experienced by the student. Anticipating and generating an appropriate set of states on which to train the student typically requires many rollouts and can thus be expensive.
+
+Since we are aiming to compress the behavior of thousands of experts we desire a computationally efficient method. We investigate two schemes that allow us to record the experts’ state-action mappings on a small-sample estimate of the experts’ state distributions and to then train the student via supervised learning. Both schemes are convenient to implement in a regular supervised learning pipeline and require neither querying many experts simultaneously (which limits scalability when dealing with thousands of experts) nor execution of the student at training time.
+
+Behavioral cloning from noisy rollouts The first approach amounts to simply gathering a number of noisy trajectories from the expert (either under a stochastic policy or with noise injection) while logging the optimal/mean action of the expert instead of the noisy action actually executed. A version of this is equivalent to the DART algorithm of Laskey et al. (2017). We then perform behavioral cloning from that data.
+
+Specifically, given an expert policy $\pi _ { E }$ , let $\mu _ { E } ( s )$ be the mean action of the expert in state $s$ . To obtain noisy rollouts, we run $\pi _ { E } ^ { \eta }$ , the expert with moderate action noise $( \eta )$ to obtain a set of data $\{ s _ { k } ^ { \eta } , \mu _ { k } \} _ { 1 \ldots K }$ , where $\mu _ { k } = \overset {  } { \mu _ { E } ( s _ { k } ^ { \eta } ) }$ . And we optimize the policy according to Eqn. 4, with the expectation over $s \sim \rho _ { E }$ being approximated by a sum over the set of state and expert-actions collected. While we expect this approach can work well, we do not expect it to be particularly efficient insofar as the expert may need to be executed for many rollouts.
+
+Linear-feedback policy cloning (LFPC) The second approach, which we refer to as linearfeedback policy cloning (LFPC), logs the action-state Jacobian as well as the expert action along a single nominal trajectory. The Jacobian can be used to construct a linear feedback controller which gives target actions in nearby perturbed states during training (described below). This approach is not intended to outperform behavioral cloning, as this should not be possible for arbitrary quantities of expert rollout data. Instead the motivation for LFPC is to do as well as behavioral cloning while using considerably fewer expert rollouts.
+
+As pointed out above, experts trained to reproduce single clips robustly can be thought of as nonlinear feedback controllers around this nominal trajectory. The nominal trajectory refers to the sequence of nominal state-action pairs $\left\{ s _ { t } ^ { \star } , a _ { t } ^ { \star } \right\} _ { 1 \ldots T }$ obtained by executing $\mu _ { E } ( s )$ recursively from an initial point $s _ { 0 } ^ { \star }$ . Since expert behavior in our setting is well characterized by single nominal trajectories, we expect we can capture the relevant behavior of the expert by a linearization around the nominal trajectory3.
+
+Let δs be a small perturbation of the state and let J = dµE(s) |s be the Jacobian. Then
+
+$$
+\mu _ { E } ( s + \delta s ) = \mu _ { E } ( s ) + \pmb { J } \delta s + O \left( \lVert \delta s \rVert ^ { 2 } \right) .
+$$
+
+This linearization induces a linear-feedback-stabilized policy that at each time-step has a nominal action $a _ { t } ^ { \star }$ , but also expects to be in state $s _ { t } ^ { \star }$ , and correspondingly adjusts the nominal action with a linear correction based on discrepancy between the nominal and actual state at time $t$ :
+
+$$
+\mu _ { F B } ( s _ { t } ) = a _ { t } ^ { \star } + { \cal J } _ { t } ^ { \star } ( s _ { t } - s _ { t } ^ { \star } ) , ~ \mathrm { w h e r e } ~ { \cal J } _ { t } ^ { \star } = \left. \frac { d \mu _ { E } ( s ) } { d s } \right| _ { s = s _ { t } ^ { \star } } .
+$$
+
+We empirically validated that a linear feedback policy about the nominal trajectory of the expert can approximate the expert behavior reasonably well for clips we examine (see results Fig. 3).
+
+Above we presented the expert as a feedback controller operating in a tube around some nominal trajectory with states $s _ { 1 } ^ { \star } , \ldots , s _ { T } ^ { \star }$ , actions $a _ { 1 } ^ { \star } , \ldots , a _ { T } ^ { \star }$ , and Jacobians $J _ { 1 } ^ { \star } , \ldots , J _ { T } ^ { \star }$ . We approximate $\rho _ { E }$ with the distribution of states introduced by state perturbations around this nominal trajectory:
+
+$$
+\operatorname* { m i n } _ { \theta } \frac { 1 } { T } \sum _ { i } \mathbb { E } _ { \delta s _ { i } \sim \Delta ( s ) } [ \| \mu _ { E } ( s _ { i } + \delta s _ { i } ) - \mu _ { \theta } ( s _ { i } + \delta s _ { i } ) \| ^ { 2 } ] .
+$$
+
+However, this objective still requires expert evaluations at the perturbed states. Using the linearization described above we can replace the expert action $\mu _ { E } ( s + \delta s )$ with the Jacobian-based linearfeedback policy $\mu _ { F B } ( s + \delta s )$ , which is available offline. This yields the LFPC objective:
+
+$$
+\operatorname* { m i n } _ { \theta } \frac { 1 } { T } \sum _ { i } \mathbb { E } _ { \delta s _ { i } \sim \Delta ( s ) } [ | | \mu _ { \theta } ( s _ { i } ^ { \star } + \delta s _ { i } ) - a _ { i } ^ { \star } - J _ { i } ^ { \star } \delta s _ { i } | | _ { 2 } ^ { 2 } ] ,
+$$
+
+One potentially important choice is the perturbation distribution $\Delta ( s )$ . Ideally, we would like $\Delta ( s )$ to be the state-dependent distribution induced by physically plausible transitions, but estimating this distribution may require potentially expensive rollouts which we are trying to avoid. A cheaper object to estimate is the stationary transition noise distribution induced by noisy actions, which can be efficiently approximated from a small number of trajectories. Empirically, we found the objective 8 to be relatively robust to some variations in $\Delta$ , and we use a fixed marginal distribution for all clips.
+
+Objective 8 bears interesting similarities to approaches such as denoising autoencoders (Vincent et al., 2008), where networks can learn to ignore local noise perturbations on inputs sampled from a high-dimensional noise distribution. Further, Mordatch et al. (2015) successfully distill feedback policies obtained from a planner. One question left open by this latter work is that of how much data might be required. Empirically we show in the experiments below that the augmented objective 8 can produce the desired robustness even from a very limited set of states.
+
+![](images/5e7a7857baecce1901177e9515c069361df513c0963b1516e980158d70530333.jpg)  
+Figure 3: Comparisons of trajectory rollouts for 4 reference behaviors for the nominal trajectory and at varying noise levels. Note that the score is determined by similarity to motion-capture reference and the expert may be slightly suboptimal so slight improvements on the expert may arise by chance.
+
+There are multiple, relevant perspectives on LFPC. From one perspective, LFPC amounts to a data augmentation method. From another vantage, the approach attempts to match the mean action as well as the Jacobian at the set of relevant behavioral states, here sampled along the nominal trajectory. In settings where expert behavior is more diverse or multimodal, LFPC should be applied to states which representatively cover relevant behavioral modes or perhaps are expanded backwards from goal states (roughly similar to the procedure used to expand LQR-trees by Tedrake 2009). Explicit Jacobian matching has been proposed elsewhere, for example in Czarnecki et al. (2017). See appendix C for further disambiguation relative to other approaches.
+
+To train our Neural Probabilistic Motor Primitive architecture using LFPC we can adapt the objective in Eqn. 3 as follows:
+
+$$
+\mathbb { E } _ { \delta s , q } \left[ \sum _ { t = 1 } ^ { T } \log \pi ( a _ { t } + J _ { t } \delta s _ { t } | s _ { t } + \delta s _ { t } , z _ { t } ) + \beta \big ( \log p _ { z } ( z _ { t } | z _ { t - 1 } ) - \log q ( z _ { t } | z _ { t - 1 } , x _ { t } + \delta x _ { t } ) \big ) \right] ,
+$$
+
+where $\delta { s } _ { t }$ are i.i.d. perturbations drawn from suitable perturbation distribution $\Delta$ and $\delta \boldsymbol { x } _ { t }$ is the concatenation of $[ \delta s _ { t } , \delta s _ { t + 1 } , . . . , \delta s _ { t + K } ]$ .
+
+# 3 EXPERIMENTS
+
+# 3.1 VALIDATION: TRANSFER OF SINGLE-BEHAVIOR POLICIES
+
+To ground our results in a simple setting, we begin with transfer of a single-skill, time-indexed policy from one network to another. We compare the performance of various time-indexed policies for each of the experts depicted in Fig. 1. We compare the original expert policy, an open-loop action sequence along the experts nominal (i.e. mean) trajectory, a linear feedback policy along the expert nominal trajectory, as well as the network trained to match the linear-feedback behavior (LFPC). In addition we compare to policies trained from 100, 200, 500 or 1000 trajectories with behavioral cloning. We compare each approach with no action noise, small action noise, and moderate action noise (noise is i.i.d. normal per actuator with standard deviation magnitude .05 and .1 respectively, for action ranges normalized to $[ - 1 , 1 ] ,$ ). Note that, open loop control almost always fails if the state is perturbed by even a small $\epsilon$ (though perhaps surprisingly, the backflip can almost be executed open loop due to limited ground contact). Remarkably, LFPC with a single trajectory performs on par with behavioral cloning based on hundreds of trajectories (see Fig. 3). For additional validation, see appendix D.
+
+![](images/21d8691d31d8d6a16a6ac2fd7667092303bc04f74dda5d129951cef9bfaf5dd8.jpg)  
+Figure 4: Performance relative to expert policies for trained neural probabilistic motor primitive models. Performance of model variations are compared on training and testing data. We compare models trained using cloning with 100 trajectories per expert for different levels of regularization, using a smaller latent space of dimension 20 rather than 60 in all other experiments, as well as LFPC.
+
+# .2 CORE RESULTS: COMPRESSING THOUSANDS OF EXPERTS
+
+Having validated that single skills can be transferred, we next consider how well we can compress behaviors of the 2707 experts in our training set into the neural probabilistic motor primitive architecture. Assessing the models using the action-reconstruction loss is not very intuitive since it does not capture model behavior in the environment. Instead we report a more relevant measure based on expert imitation. Here we encode an expert trajectory into a sequence of latent variables and then execute the policy in the environment conditioned on this sequence. Note that this approach is openloop with respect to the latents while being closed-loop with respect to state. We can then compare the performance of the trained system against experts on training and held-out clips according to the tracking reward used to train the experts originally. To account for different expert reward scales we report performance relative to the expert policy. Importantly, that this approach works is itself a partial validation of the premise of this work, insofar as open-loop execution of action sequences usually trivially fails with minor perturbations. The trained neural probabilistic motor primitive system can execute behaviors conditioned on an open-loop noisy latent variable trajectory, implying that the decoder has learned to stabilize the body during latent-conditioned behavior.
+
+There are a few key takeaways from the comparisons we have run (see Fig. 4). Most saliently cloning based on 100 trajectories from each expert with a medium regularization value $( \beta = 0 . 1 )$ works best. LFPC with comparable parameters works less well here, but has qualitatively fairly similar performance. Our ablations show that regularization and a large latent space are important for good results. We also set the autoregressive parameter $\alpha = 0$ (.95 in other runs), making the latent variables i.i.d.. This hurts performance, validating our choice of prior.4
+
+# 3.3 ANALYSIS OF THE TRAINED MODEL
+
+We have no expectation that trajectories well outside the training distribution are likely to be either representable by the encoder or executable by the decoder. Nevertheless, when one-shot imitation of a trajectory fails, a natural question is whether the decoder is incapable of expressing the desired actions, or the encoder fails to encode the trajectory in such a way that the decoder will produce it.
+
+![](images/e1b92e17a4ed8432b233f2b136d87bbb1a350c2d3caffd6e38c50aefdef8a308.jpg)  
+Figure 5: These panels consist of visualizations of the PCA latent space with comparisons in this space between one-shot latent-variable sequences and optimized latent variable sequences for various behaviors: A. Run B. Backwards walking C. Jumping. Running executes well based on the one-shot trajectory so serves as a reference for which optimization is not noticeably different. Walking backwards and jumping one-shot imitations fail, but are noticeably improved by optimization.
+
+We propose an analysis to distinguish this for borderline cases. For held out trajectories that yield unsatisfying performance on one-shot imitation, we can simply optimize directly:
+
+$$
+\operatorname* { m i n } _ { z _ { 1 } . . . z _ { T } } \sum _ { t = 1 } ^ { T } | | \mu _ { \boldsymbol { \theta } } ( s _ { t } , z _ { t } ) - a _ { t } ^ { \star } | | _ { 2 } ^ { 2 } ,
+$$
+
+where $\mu _ { \theta }$ is the decoder mean. Empirically we see that this optimization meaningfully improves the executed behavior, and we visualize the shift in a three-dimensional space given by the first three principal components in Fig. 5.
+
+We exhibit three examples where we visualize the original latent trajectory as well as the optimized latent trajectory. Performance is significantly improved (see supplementary video), showing the latent space can represent behaviors for which one-shot imitation fails. However execution remains imperfect suggesting that while much of the fault may lie with the encoder, the decoder still may be slightly undertrained on these relatively rare behavior categories. Quantitatively, among a larger set of clips with less than $50 \%$ relative expert performance for one-shot imitation we found that optimization as described above improved median relative expert performance from $43 \%$ to $78 \%$ .
+
+Other exploratory probes of the module suggest that it is possible in certain cases to obtain seamless transitioning between behaviors by concatenating latent-variable trajectories and running the policy conditioned on this sequence (e.g. in order to perform a sequence of turns). See additional supplementary video.
+
+Reuse of motor primitive module Finally, we experimented with reuse of the decoder as a motor primitive module. We treat the latent space as a new custom action space and train a new high-level (HL) policy to operate in this space. At each time-step the high-level policy outputs a latent-variable
+
+![](images/64f8148d800dc134663ee5a1997292e43576ba9acf8a4419c1d584c2b65604b2.jpg)
+
+(a) Median return value across 10 seeds for the goto-target task vs learner steps. Compared to a very weakly regularized module $( \beta ~ = ~ 0 . 0 0 1 )$ ), more regularized motor primitives modules both trained faster and achieved higher final performance.
+
+![](images/b7b9c3e9b1c45beb1656f2c4740036f4252345f4c4908840e280484b1144511d.jpg)
+
+(b) Our model is able to track the target speed accurately. Shown here are target speed and actual speed in the egocentric forward direction for three episodes. The reward function is a Gaussian centered at the target speed. The shaded region corresponds to $\pm$ one standard deviation.
+
+Figure 6: Reuse of neural probabilistic motor primitive modules.
+
+$z _ { t }$ . The actual action is then given by the motor primitive module $p ( a _ { t } | s _ { t } , z _ { t } )$ . For training we used SVG(0) (Heess et al., 2015) with the Retrace off-policy correction for learning the Q-function (Munos et al., 2016).
+
+A natural locomotion task that can challenge the motor module is a task which requires abrupt, frequently redirected movement with sharp turns and changes of speed. To implement this we provide the higher-level controller with a target that is constant until the humanoid is near it for a few timesteps at which point it randomly moves to another nearby location. While no single task will comprehensively probe the module, performing well in this task demands a wide range of quick locomotion behavior. With only a sparse task reward, the HL-controller can learn to control the body through the learned primitive space, and it produces rather humanlike task-directed movement. We observed that more regularized motor primitive modules had more stable initial behavior when connected to the untrained high-level controller (i.e. were less likely to fall at the beginning of training). Compared to a very weakly regularized module $( \beta = 0 . 0 0 1 )$ , more regularized motor primitives modules both trained faster and achieved higher final performance (see Fig. 6a). We also investigated a go-to-target task with bumpy terrain that is unobserved by the agent. The fact that our model can learn to solve this task demonstrates its robustness to unseen perturbations for which the motor primitive module was not explicitly trained. In another experiment we investigated a task in which the agent has to move at a random, changing target speed. This requires transitions between qualitatively different locomotion behavior such as walking, jogging, and running (see Fig. 6b). See an extended video of these experiments. In a final reuse experiment, we consider an obstacle course requiring the agent to jump across gaps (as in Merel et al. (2018)). We were able to solve this challenging task with a high-level controller that operated using egocentric visual inputs (see the main supplementary video).
+
+We emphasize a few points about these results to impact their importance: (1) Using a pretrained neural probabilistic motor primitives module, new controllers can be trained effectively from scratch on sparse reward tasks, (2) the resulting movements are visually rather humanlike without additional constraints implying that the learned embedding space is well structured, and (3) the module enables fairly comprehensive and smooth coverage for the purposes of physics-based control.
+
+# 4 DISCUSSION
+
+In this paper we have described approaches for transfer and compression of control policies. We have exhibited a motor primitive module that learns to represent and execute motor behaviors for control of a simulated humanoid body. Using either a variant of behavioral cloning or linear feedback policy cloning we can train the neural probabilistic motor primitive sytem to perform robust one-shotimitation, and with the latter we can use relatively restricted data consisting of only single rollouts from each expert. While LFPC did not work quite as well in the full-scale model as cloning from noisy rollouts, we consider it remarkable that it is possible in our setting to transfer expert behavior using a single rollout. We believe LFPC holds promise insofar as it may be useful in settings where rollouts are costly to obtain (e.g. adapted to real-world robotic applications), and there is room for further improvement as we did not carefully tune certain parameters, most saliently the marginal noise distribution $\Delta$ .
+
+The resulting neural probabilistic motor primitive module is interpretable and reusable. We are optimistic that this kind of architecture could serve as a basis for further continual learning of motor skills. This work has been restricted to motor behaviors which do not involve interactions with objects and where a full set a of behaviors are available in advance. Meaningful extensions of this work may attempt to greatly enrich the space of behaviors or demonstrate how to perform continual learning and reuse of new skills.
+
+# ACKNOWLEDGMENTS
+
+The data used in this project was obtained from mocap.cs.cmu.edu. The database was created with funding from NSF EIA-0196217.
+
+# REFERENCES
+
+Alexander A Alemi, Ian Fischer, Joshua V Dillon, and Kevin Murphy. Deep variational information bottleneck. International Conference on Learning Representations, 2017.
+
+Michael Athans. The role and use of the stochastic linear-quadratic-gaussian problem in control system design. IEEE transactions on automatic control, 16(6):529–552, 1971.
+
+Trapit Bansal, Jakub Pachocki, Szymon Sidor, Ilya Sutskever, and Igor Mordatch. Emergent complexity via multi-agent competition. International Conference on Learning Representations, 2018.
+
+E Bizzi, VCK Cheung, A d’Avella, P Saltiel, and Matthew Tresch. Combining modules for movement. Brain research reviews, 57(1):125–133, 2008.
+
+Nuttapong Chentanez, Matthias Muller, Miles Macklin, Viktor Makoviychuk, and Stefan Jeschke. ¨ Physics-based motion capture imitation with deep reinforcement learning. In Proceedings of the 11th Annual International Conference on Motion, Interaction, and Games, pp. 1. ACM, 2018.
+
+Wojciech M Czarnecki, Simon Osindero, Max Jaderberg, Grzegorz Swirszcz, and Razvan Pascanu. Sobolev training for neural networks. In Advances in Neural Information Processing Systems, pp. 4281–4290, 2017.
+
+Kai Ding, Libin Liu, Michiel Van de Panne, and KangKang Yin. Learning reduced-order feedback policies for motion skills. In Proceedings of the 14th ACM SIGGRAPH/Eurographics Symposium on Computer Animation, pp. 83–92. ACM, 2015.
+
+Yan Duan, Marcin Andrychowicz, Bradly Stadie, OpenAI Jonathan Ho, Jonas Schneider, Ilya Sutskever, Pieter Abbeel, and Wojciech Zaremba. One-shot imitation learning. In Advances in neural information processing systems, pp. 1087–1098, 2017.
+
+Tommaso Furlanello, Zachary C Lipton, Michael Tschannen, Laurent Itti, and Anima Anandkumar. Born again neural networks. arXiv preprint arXiv:1805.04770, 2018.
+
+Michael Graziano. The organization of behavioral repertoire in motor cortex. Annu. Rev. Neurosci., 29:105–134, 2006.
+
+Nicolas Heess, Gregory Wayne, David Silver, Tim Lillicrap, Tom Erez, and Yuval Tassa. Learning continuous control policies by stochastic value gradients. In Advances in Neural Information Processing Systems, pp. 2944–2952, 2015.
+
+Nicolas Heess, Srinivasan Sriram, Jay Lemmon, Josh Merel, Greg Wayne, Yuval Tassa, Tom Erez, Ziyu Wang, Ali Eslami, Martin Riedmiller, et al. Emergence of locomotion behaviours in rich environments. arXiv preprint arXiv:1707.02286, 2017.
+
+Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015.
+
+David H. Jacobson and David Q. Mayne. Differential Dynamic Programming. Elsevier, 1970.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. International Conference on Learning Representations, 2015.
+
+Diederik P Kingma and Max Welling. Auto-encoding variational bayes. International Conference on Learning Representations, 2013.
+
+Michael Laskey, Jonathan Lee, Roy Fox, Anca Dragan, and Ken Goldberg. Dart: Noise injection for robust imitation learning. In Conference on Robot Learning, pp. 143–156, 2017.
+
+Libin Liu and Jessica Hodgins. Learning basketball dribbling skills using trajectory optimization and deep reinforcement learning. ACM Transactions on Graphics (TOG), 37(4):142, 2018.
+
+Libin Liu, KangKang Yin, Michiel van de Panne, Tianjia Shao, and Weiwei Xu. Sampling-based contact-rich motion control. In ACM Transactions on Graphics (TOG), volume 29, pp. 128. ACM, 2010.
+
+David Mayne. A second-order gradient method for determining optimal trajectories of non-linear discrete-time systems. International Journal of Control, 3(1):85–95, 1966.
+
+Franziska Meier and Stefan Schaal. A probabilistic representation for dynamic movement primitives. arXiv preprint arXiv:1612.05932, 2016.
+
+Josh Merel, Yuval Tassa, Sriram Srinivasan, Jay Lemmon, Ziyu Wang, Greg Wayne, and Nicolas Heess. Learning human behaviors from motion capture by adversarial imitation. arXiv preprint arXiv:1707.02201, 2017.
+
+Josh Merel, Arun Ahuja, Vu Pham, Saran Tunyasuvunakool, Siqi Liu, Dhruva Tirumala, Nicolas Heess, and Greg Wayne. Hierarchical visuomotor control of humanoids. arXiv preprint arXiv:1811.09656, 2018.
+
+Igor Mordatch, Kendall Lowrey, Galen Andrew, Zoran Popovic, and Emanuel V Todorov. Interactive control of diverse complex characters with neural networks. In Advances in Neural Information Processing Systems, pp. 3132–3140, 2015.
+
+Jun Morimoto and Christopher G Atkeson. Minimax differential dynamic programming: An application to robust biped walking. In Advances in neural information processing systems, pp. 1563–1570, 2003.
+
+Remi Munos, Tom Stepleton, Anna Harutyunyan, and Marc Bellemare. Safe and efficient off-policy ´ reinforcement learning. In Advances in Neural Information Processing Systems, pp. 1054–1062, 2016.
+
+Gerhard Neumann, Christian Daniel, Alexandros Paraschos, Andras Kupcsik, and Jan Peters. Learning modular policies for robotics. Frontiers in computational neuroscience, 8:62, 2014.
+
+Alexandros Paraschos, Christian Daniel, Jan R Peters, and Gerhard Neumann. Probabilistic movement primitives. In Advances in neural information processing systems, pp. 2616–2624, 2013.
+
+Emilio Parisotto, Jimmy Lei Ba, and Ruslan Salakhutdinov. Actor-mimic: Deep multitask and transfer reinforcement learning. arXiv preprint arXiv:1511.06342, 2015.
+
+Xue Bin Peng, Glen Berseth, KangKang Yin, and Michiel Van De Panne. Deeploco: Dynamic locomotion skills using hierarchical deep reinforcement learning. ACM Transactions on Graphics (TOG), 36(4):41, 2017.
+
+Xue Bin Peng, Pieter Abbeel, Sergey Levine, and Michiel van de Panne. Deepmimic: Example-guided deep reinforcement learning of physics-based character skills. arXiv preprint arXiv:1804.02717, 2018.
+
+Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In Proceedings of the 31st International Conference on International Conference on Machine Learning - Volume 32, ICML’14, pp. II–1278– II–1286. JMLR.org, 2014. URL http://dl.acm.org/citation.cfm?id $=$ 3044805. 3045035.
+
+Stephane Ross, Geoffrey Gordon, and Drew Bagnell. A reduction of imitation learning and struc- ´ tured prediction to no-regret online learning. In Proceedings of the fourteenth international conference on artificial intelligence and statistics, pp. 627–635, 2011.
+
+Andrei A Rusu, Sergio Gomez Colmenarejo, Caglar Gulcehre, Guillaume Desjardins, James Kirkpatrick, Razvan Pascanu, Volodymyr Mnih, Koray Kavukcuoglu, and Raia Hadsell. Policy distillation. arXiv preprint arXiv:1511.06295, 2015.
+
+Stefan Schaal, Jan Peters, Jun Nakanishi, and Auke Ijspeert. Learning movement primitives. In International Symposium on Robotics Research, (ISRR), 2003.
+
+John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In International Conference on Machine Learning, pp. 1889–1897, 2015.
+
+Suraj Srinivas and Franc¸ois Fleuret. Knowledge transfer with jacobian matching. CoRR, abs/1803.00443, 2018. URL http://arxiv.org/abs/1803.00443.
+
+Yuval Tassa, Tom Erez, and Emanuel Todorov. Synthesis and stabilization of complex behaviors through online trajectory optimization. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp. 4906–4913. IEEE, 2012.
+
+Yuval Tassa, Nicolas Mansard, and Emo Todorov. Control-limited differential dynamic programming. In Robotics and Automation (ICRA), 2014 IEEE International Conference on, pp. 1168– 1175. IEEE, 2014.
+
+Russ Tedrake. LQR-trees: Feedback motion planning on sparse randomized trees. 2009.
+
+Yee Whye Teh, Victor Bapst, Wojciech M Czarnecki, John Quan, James Kirkpatrick, Raia Hadsell, Nicolas Heess, and Razvan Pascanu. Distral: Robust multitask reinforcement learning. In Advances in Neural Information Processing Systems, pp. 4499–4509, 2017.
+
+Emanuel Todorov and Zoubin Ghahramani. Unsupervised learning of sensory-motor primitives. In Engineering in Medicine and Biology Society, 2003. Proceedings of the 25th Annual International Conference of the IEEE, volume 2, pp. 1750–1753. IEEE, 2003.
+
+Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp. 5026– 5033. IEEE, 2012.
+
+Pascal Vincent, Hugo Larochelle, Yoshua Bengio, and Pierre-Antoine Manzagol. Extracting and composing robust features with denoising autoencoders. In Proceedings of the 25th international conference on Machine learning, pp. 1096–1103. ACM, 2008.
+
+Ziyu Wang, Josh S Merel, Scott E Reed, Nando de Freitas, Gregory Wayne, and Nicolas Heess. Robust imitation of diverse behaviors. In Advances in Neural Information Processing Systems, pp. 5320–5329, 2017.
+
+# APPENDICES
+
+# A MOTION CAPTURE EXPERTS
+
+The approach we use for producing experts is detailed more fully in Merel et al. (2018). In short, this approach for producing experts largely follows Peng et al. (2018). We took the energy function proposed in SAMCON (Liu et al., 2010), and use it as a per timestep reward to train a time-indexed policy that tracks/imitates a motion capture reference clip (Peng et al., 2018). As proposed in Merel et al. (2017); Peng et al. (2018), episodes are initialized to poses throughout the motion capture reference and episodes are early-terminated when the character falls. Here we use an off-policy RL algorithm, SVG(0) (Heess et al., 2015) with Retrace (Munos et al., 2016). As done in Merel et al. (2017); Peng et al. (2018) and elsewhere, we train stochastic policies and use the mean (i.e. noiseless) action as the expert policy.
+
+# B ARCHITECTURE AND TRAINING DETAILS
+
+The decoder $p ( a _ { t } | s _ { t } , z _ { t } )$ in our experiments was a MLP with three layers with 1024 hidden units taking as input the concatenation of state $s _ { t }$ and latent variable $z _ { t }$ . The decoder output distribution is a multivariate Gaussian with fixed standard deviation of 0.1 (action values are normalized to $[ - 1 , 1 ] ,$ ). We found that fixing the standard deviation made it significantly easier to prevent overfitting. Note that in this setting varying the $\beta$ parameter is equivalent to varying the fixed output variance (up to a constant). The encoder $q ( z _ { t } | \boldsymbol { z } _ { t - 1 } , \boldsymbol { x } _ { t } )$ in our experiments was also an MLP with two layers of 1024 hidden units each. The inputs were simply concatenated at the input. The encoder output distribution was a multivariate Gaussian with learnt variance. In most of our experiments, we used a 60-dimensional latent space.
+
+We used the reparametrization trick (Kingma & Welling, 2013; Rezende et al., 2014) to train the model and used stochastic gradient descent with ADAM (Kingma & Ba, 2015) with a learning rate of 0.0001. In the case of models trained on 100 trajectories per expert we used minibatches of 512 subsequences of length 30.
+
+For LFPC we sampled 32 subsequences of length 30 and produced 5 perturbed state sequences per subsequence. In preliminary experiments the length of the subsequences did not have a major impact on model performance.
+
+# C RELATIONSHIP TO OTHER KNOWLEDGE TRANSFER IDEAS
+
+Firstly, we note that the emphasis of the proposal in this work is to match the responsivity of the expert policy in a neighborhood around each state. This is distinct from activation matching or KL matching where the emphasis is on matching the action/activation distribution for a particular state (Rusu et al., 2015; Teh et al., 2017). Secondly, we emphasize that the kind of robust knowledge transfer we discuss here is distinct from that which is seen to be important in other settings. For example Srinivas & Fleuret (2018) provide a line of reasoning that involves training a student system to match the exact activations of a teacher in the presence of perturbations on the student inputs. This logic is sound in the setting of large-scale vision systems. However in the context of control policies, this would look like:
+
+$$
+\operatorname* { m i n } _ { \theta } \sum _ { s \in S ^ { \star } } \mathbb { E } _ { \delta s \sim \Delta ( s ) } [ ( \mu _ { E } ( s ) - \mu _ { \theta } ( s + \delta s ) ) ^ { 2 } ]
+$$
+
+This essentially means that the student policy is learning to “blindly” reproduce the action of the expert exactly, despite input perturbations. While this is well motivated if the noise is thought to be orthogonal to the proper functioning of the system, this is a very bad idea for control, where you need to pay close attention to small input perturbations. Technically, this amounts to setting the local feedback to zero, and behaving in a sort of open-loop-like fashion.
+
+# D VISUALIZATION OF STATIONARY POLICY BEHAVIOR
+
+Locomotion behavior is, at least in the simplest case roughly a limit cycle. In an additional experiment to test LFPC we gathered three gait cycles of running behavior and performed LFPC. Note that here the student policy need not be time-indexed even when the demonstrations were time-indexed. This restricted case shows striking generalization in the presence of noise (see Fig. A.1 and also see main supplementary video).
+
+![](images/dfcdc7f26b0d7f77ba20247a5d80cda6f4765a026626458e74274d2edd13a3e8.jpg)  
+Figure A.1: Dimensionality reduction (PCA) performed on set of poses obtained from noisy rollouts of the stationary cloned policy (blue). The limited reference data originating from a time-indexed policy has been projected into the same space (green). Observe that the rollouts are considerably noisier and consistently deviate from the reference trajectory, nevertheless the cloned-policy trajectories return to the limit cycle.

parse/train/BJl6TjRcY7/BJl6TjRcY7_content_list.json

@@ -0,0 +1,1788 @@
+[
+    {
+        "type": "text",
+        "text": "NEURAL PROBABILISTIC MOTOR PRIMITIVES FOR HUMANOID CONTROL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            764,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Josh Merel∗, Leonard Hasenclever∗, Alexandre Galashov,   \nArun Ahuja, Vu Pham, Greg Wayne, Yee Whye Teh, & Nicolas Heess   \nDeepMind   \nLondon, UK   \n{jsmerel,leonardh,agalashov,arahuja,vuph, gregwayne,ywteh,heess}@google.com ",
+        "bbox": [
+            184,
+            170,
+            665,
+            253
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            290,
+            544,
+            305
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We focus on the problem of learning a single motor module that can flexibly express a range of behaviors for the control of high-dimensional physically simulated humanoids. To do this, we propose a motor architecture that has the general structure of an inverse model with a latent-variable bottleneck. We show that it is possible to train this model entirely offline to compress thousands of expert policies and learn a motor primitive embedding space. The trained neural probabilistic motor primitive system can perform one-shot imitation of whole-body humanoid behaviors, robustly mimicking unseen trajectories. Additionally, we demonstrate that it is also straightforward to train controllers to reuse the learned motor primitive space to solve tasks, and the resulting movements are relatively naturalistic. To support the training of our model, we compare two approaches for offline policy cloning, including an experience efficient method which we call linear feedback policy cloning. We encourage readers to view a supplementary video summarizing our results. ",
+        "bbox": [
+            233,
+            321,
+            764,
+            515
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            542,
+            334,
+            558
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A broad challenge in machine learning for control and robotics is to produce policies capable of general, flexible, and adaptive behavior of complex, physical bodies. To build policies that can effectively control simulated humanoid bodies, researchers must simultaneously overcome foundational challenges related to high-dimensional control, body balance, and locomotion. Recent progress in deep reinforcement learning has raised hopes that such behaviors can be learned end-to-end with minimal manual intervention. Yet, even though significant progress has been made thanks to better algorithms, training regimes, and computational infrastructure, the resulting behaviors still tend to exhibit significant idiosyncrasies (e.g. Heess et al., 2017; Bansal et al., 2018). ",
+        "bbox": [
+            174,
+            573,
+            825,
+            685
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One advantage of working with humanoids in this context is that motion capture data is widely available and can serve to help design controllers that produce apparently humanlike movement. Indeed, recent developments are now allowing for the production of highly specialized expert policies which robustly, albeit narrowly, reproduce single motion capture clips (e.g. Liu et al. (2010); Peng et al. (2018)). ",
+        "bbox": [
+            174,
+            691,
+            823,
+            762
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A remaining challenge on the way to truly flexible and general purpose control is to be able to sequence and generalize individual movements or “skills” in a task-directed manner. Achieving this goal requires not just the ability to acquire individual skills in the first place, but also an architecture and associated training procedure that supports representation, recruitment, and composition of a large number of skills. ",
+        "bbox": [
+            174,
+            768,
+            823,
+            838
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper presents a step in this direction. Specifically, the setting we focus on will be one in which we have a large number of robust experts that perform single skills well and we wish to transfer these skills into a shared policy that can do what each expert does as well as the expert, while also generalizing to unseen behaviors within the distribution of skills. To this end we design a system that performs one-shot imitation as well as permits straightforward reuse (or transfer) of skills. We require our approach to scale to a very large number of individual skills while also keeping manual intervention and oversight to a minimum. ",
+        "bbox": [
+            174,
+            845,
+            823,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our primary contribution is the development of a neural network architecture that can represent and generate many motor behaviors, which we refer to as neural probabilistic motor primitives. This architecture is designed to perform one-shot imitation, while learning a dense embedding space of a large number of individual motor skills. Once trained, this module does not just reproduce individual behaviors in the training data, but can sequence and compose these behaviors in a controlled fashion as well as synthesize novel movements consistent with the training data distribution. Empirically, we also find that training controllers to reuse this learned motor primitive module for new tasks generates surprisingly human-like movement and the behavior generated seems to interpolate the space of behaviors well. ",
+        "bbox": [
+            174,
+            152,
+            823,
+            277
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In order to facilitate transfer and compression of expert skills at the scale of thousands of behaviors, we wish to avoid closed-loop RL training. We call the general, offline, functional transfer of policy content policy transfer or policy cloning and consider two approaches. The natural baseline approach involves the application of behavioral cloning to data gathered by executing experts many times, with noise, and logging intended expert actions, resembling the approach of Laskey et al. (2017). This works well, as it ensures the student behaves like the expert not only along nominal expert rollouts but also at points arrived at by perturbing the expert. However, this approach may require many rollouts, which can be costly to obtain in many settings. As a more efficient alternative we therefore consider a second solution that operates by comprehensively transferring the functional properties of an expert to a student policy by matching the local noise-feedback properties along one or a small number of representative expert reference trajectories. We call this specific proposal linear feedback policy cloning (LFPC), and we demonstrate that it is competitive with behavioral cloning from many more rollouts in our setting. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            465
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1.1 BACKGROUND & RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            491,
+            450,
+            506
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recent efforts in RL for humanoid control build on a large body of research in robotics and animation. While contemporary results for learning from scratch (Schulman et al., 2015; Heess et al., 2017) can be impressive the behaviors are not consistently human-like. Learning from motion capture (mocap) can provide strong constraints, especially for running (Peng et al., 2017; Merel et al., 2017). Several recent approaches have demonstrated that it is possible to acquire specific behavioral skills, possibly jointly with external RL objectives (Merel et al., 2017; Peng et al., 2018; Liu & Hodgins, 2018). At present, the policies produced tend to be restricted to single skills/behaviors and can require very large quantities of environment interactions, motivating us to seek methods which reuse existing single-skill expert policies. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            645
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Knowledge transfer refers to the broad class of approaches which transfer the input-output functional mapping, to some extent or another, from a teacher (or expert) to a student (Hinton et al., 2015; Srinivas & Fleuret, 2018; Furlanello et al., 2018). Distillation connotes the transfer of function from one or more expert systems into a single student system often with the goal of compression or of combining multiple experts qualities (Hinton et al., 2015; Parisotto et al., 2015; Rusu et al., 2015; Teh et al., 2017). Imitation learning is the control-specific term for the production of a student policy from either an expert policy or the behavioral demonstrations of an expert. One basic algorithm is behavioral cloning, which refers to supervised training of the policy from state-action pairs. In the most simple case it only requires examples from the expert. A broader setting is that in which more liberal queries to the expert are permitted; e.g. for the online-imitation setting as in DAGGER (Ross et al., 2011). This setting is often satisfied e.g. if we wish to combine behavior from multiple experts. ",
+        "bbox": [
+            174,
+            652,
+            825,
+            805
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "One-shot imitation is a concept which means that a trained system, at test time, can watch an example behavior and imitate it, as, for instance, in Duan et al. (2017). More similar to our work is the setting examined by Wang et al. (2017), in which full-body humanoid movements were studied. Compared with this latter work, we will employ an architecture here that encourages imitation of motor details, rather than overall movement type, and we scale our approach to more expert demonstrations. The most similar work also demonstrates large-scale one-shot humanoid tracking and was contemporaneously published (Chentanez et al., 2018); the approach they described involves direct tracking as well as failure recovery, but relative to our work the authors do not consider skill reuse. ",
+        "bbox": [
+            174,
+            813,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The notion of motor primitives is widespread in neuroscience, where there is evidence that lower dimensional control signals can selectively coordinate and blend behaviors produced by spinal circuits (Bizzi et al., 2008), and that the cortex organizes the space of primitive motor behaviors (Graziano, 2006). In our setting, motor primitives refer to the reusable embedding space learned from many related behaviors and the associated context-modulable policy capable of generating sensory-feedback-stabilized motor behavior when executed in an environment. The particular architecture we consider is inspired by the formalization presented in Todorov & Ghahramani (2003), which places a probabilistic latent bottleneck on the sensory-motor mapping. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the robotics literature, there is a rich line of research into various parameterizations of motion trajectories used for robot control. A class of these are referred to as “movement primitives” (e.g. Schaal et al., 2003), including the “probabilistic movement primitives” of Paraschos et al. (2013) (see also e.g. Neumann et al., 2014). These approaches can be seen as specific implementation choices for a certain notion of motor primitive, which emphasize the parameterization and learning of movement trajectories from repeated demonstrations (Paraschos et al., 2013; Meier & Schaal, 2016), rather than learning the actuation/stabilization element, which is often handled by a prespecified PID controller. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            333
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "It has previously been recognized that linear-feedback policies can work well around optimal trajectories or limit cycles even for high DoF bodies. These can be obtained by sample-based optimization (e.g. Ding et al. (2015)) or by differential dynamic programming (Morimoto & Atkeson, 2003; Tassa et al., 2012; 2014). For linear-quadratic-Gaussian control (Athans, 1971) or differential dynamic programming (Mayne, 1966; Jacobson & Mayne, 1970), we obtain feedback policies where the feedback terms are computed from the value function, amounting effectively to feedbackstabilized plans. Work by Mordatch et al. (2015) has shown that linear-feedback policies resulting from trajectory optimization can be used to train neural networks. We employ a similar idea to transfer optimal behavior from an existing policy, observing that an optimal policy implicitly reflects the structure of the (local) value landscape and appropriately functions as a feedback controller. ",
+        "bbox": [
+            173,
+            339,
+            825,
+            479
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 TRANSFER AND COMPRESSION OF EXPERT BEHAVIORS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            520,
+            658,
+            535
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we will first briefly describe the expert policies used in this work (Sec. 2.1). We then describe the Neural Probabilistic Motor Primitive architecture and objective (Sec. 2.2). We then describe two approaches for training the module offline (Sec. 2.3). ",
+        "bbox": [
+            174,
+            561,
+            483,
+            645
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 OBTAINING EXPERTS FROM MOTION CAPTURE DATA ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            683,
+            465,
+            709
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In order to study how to transfer and consolidate experts, we must be able to generate adequate quantities of expert data. For this work, we use expert policies trained to reproduce motion capture clips. The approach we use for producing experts is detailed more fully in Merel et al. (2018) and largely follows Peng et al. (2018). It yields time-indexed neural network policies that are robust to moderate amounts of action noise (see appendix A for additional details on the training procedure). Some examples of the resulting single-skill time-indexed policies that are obtained from this procedure are ",
+        "bbox": [
+            174,
+            729,
+            482,
+            914
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/ed05edca419a26dd84104549cc8c7d14ebd4df72f1b45677f99f84c005c33920.jpg",
+        "image_caption": [
+            "Figure 1: Examples of representative experts learned from motion capture. From top to bottom, these are “run and dodge”, “cartwheel”, “backflip”, and “twist”. See accompanying video. Note that these four behaviors will be used as representative examples for validation in single-skill transfer experiments. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            498,
+            568,
+            821,
+            755
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "depicted in Fig. 1. All our experts were trained in MuJoCo environments (Todorov et al., 2012). ",
+        "bbox": [
+            173,
+            910,
+            800,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/8d1159e1a0b22d68408b930ec7b3e7195347dcbe39ee0df412b234bd8ff5fcbd.jpg",
+        "image_caption": [
+            "Figure 2: Neural probabilistic motor primitive architecture for one-shot skill deployment. The yellow-highlighted information are available for offline, supervised training. Once the full model has been learned, the decoder can be reused as a policy in other settings. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            259,
+            99,
+            736,
+            222
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Data We use the CMU Mocap database1, which contains more than 2000 clips of varying lengths from more than 100 subjects. The motions in this dataset are quite varied, including many clips of walking, turning, running, jumping, dancing, various hand movements, and many more idiosyncratic behaviors. From this, we selected various clips of generic whole-body movements – any clips longer than 6 seconds were cut into smaller pieces yielding approximately 3000, roughly 2-6 second snippets. Just over half of these are generic locomotion such as walking, running, jumping and turning. The rest of the clips mostly contained diverse hand movements while standing. We trained one expert policy per selected snippet, yielding 2707 expert policies in our training set. ",
+        "bbox": [
+            173,
+            305,
+            825,
+            417
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 NEURAL PROBABILISTIC MOTOR PRIMITIVES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            435,
+            526,
+            449
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our goal is to obtain a motor primitive module that can flexibly and robustly deploy, sequence, and interpolate a diverse set of skills from a large database of reference trajectories without any manual alignment or other processing of the raw experts. This requires a representation that does not just reliably encode all behavioral modes but also allows effective indexing of behaviors for recall. To ensure plausible and reliable transitions it is further desirable that the encoding of similar behaviors should be close in some sense in the representation space. ",
+        "bbox": [
+            174,
+            460,
+            825,
+            544
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Compression of many expert skills via a latent variable inverse model We achieve this goal by training an autoregressive latent variable model of the state-conditional action sequence which, at training time, is conditioned on short look-ahead snippets of the nominal/reference trajectory (see Fig. 2). This architecture has the general structure of an inverse model, which produces actions based on the current state and a target. The architecture and training scheme are designed for the embedding space to reflect short-term motor behavior. As we demonstrate below, this allows for the selective execution of particular behavioral modes and also admits one-shot imitation via the trajectory encoder. ",
+        "bbox": [
+            173,
+            559,
+            825,
+            670
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We use a model with a latent variable $z _ { t }$ at each time step, modelling the state conditional action distribution. The encoder and decoder are distributions $q ( \\boldsymbol { z } _ { t } | \\boldsymbol { z } _ { t - 1 } , \\boldsymbol { x } _ { t } )$ and $\\pi ( a _ { t } | \\boldsymbol { z } _ { t } , \\boldsymbol { s } _ { t } )$ where $s _ { t }$ is the state as in preceding sections and $x _ { t }$ is concatenation of a small number of future states $x _ { t } = [ s _ { t } , . . . , s _ { t + K } ]$ . The encoder and decoder are MLPs with two and three layers, respectively. For architecture and experimental details see appendix B. The generative part of the model is given by: ",
+        "bbox": [
+            173,
+            676,
+            825,
+            747
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bdbe1a9ed1ccba7475d5fb708e0eeed7987c0b395baeedfac5d5323b96bcd902.jpg",
+        "text": "$$\np ( a _ { 1 : T } , z _ { 1 : T } | s _ { 1 : T } ) = \\prod _ { t = 1 } ^ { T } p _ { z } ( z _ { t } | z _ { t - 1 } ) \\pi ( a _ { t } | z _ { t } , s _ { t } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            752,
+            661,
+            795
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Temporally nearby trajectory snippets should have a similar representation in the latent space. To implement this intuition, we choose an AR(1) process as a weak prior: ",
+        "bbox": [
+            173,
+            799,
+            826,
+            828
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fd9efb207658957d282f2c53dd31826f1304a2229723413b973e6d2c92583f2d.jpg",
+        "text": "$$\nz _ { t } = \\alpha z _ { t - 1 } + \\sigma \\epsilon , \\ \\epsilon \\sim \\mathcal { N } ( 0 , I ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            833,
+            606,
+            849
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\sigma = \\sqrt { 1 - \\alpha ^ { 2 } }$ , ensuring that marginally $z _ { t } \\sim \\mathcal { N } ( 0 , I )$ , and set $\\alpha = 0 . 9 5$ in experiments unless otherwise stated. In subsequent efforts, it may be interesting to investigate different values of $\\alpha$ and learnable priors. ",
+        "bbox": [
+            174,
+            857,
+            825,
+            900
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In order to train this model, we consider the evidence lower bound (ELBO): ",
+        "bbox": [
+            173,
+            103,
+            671,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0cd9f9d6f3a55a3ef2f17318248a9a25411e3d605e31fed921991cf965e4a794.jpg",
+        "text": "$$\n\\mathbb { E } _ { q } \\left[ \\sum _ { t = 1 } ^ { T } \\log \\pi ( a _ { t } | s _ { t } , z _ { t } ) + \\beta \\big ( \\log p _ { z } ( z _ { t } | z _ { t - 1 } ) - \\log q ( z _ { t } | z _ { t - 1 } , x _ { t } ) \\big ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            267,
+            123,
+            727,
+            167
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "with a $\\beta$ parameter to tune the weight of the prior. For $\\beta = 1$ this objective forms the well-known variational lower bound to $\\log p ( a _ { 1 : T } | s _ { 1 : T } )$ . This objective can be optimized using supervised learning (i.e. behavioral cloning from noisy rollouts) offline. ",
+        "bbox": [
+            176,
+            179,
+            823,
+            222
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note we chose not to condition the encoder on actions, since we are interested in one-shot imitation in settings where actions are unobserved. We experimented with different values of $K$ and obtained similar performance. All the results reported in this paper use $K = 5$ .2 ",
+        "bbox": [
+            176,
+            228,
+            821,
+            271
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our architecture effectively implements a conditional information bottleneck between the desired future trajectory $x _ { t }$ and the action $a _ { t }$ given the past latent state $z _ { t - 1 }$ (similar to Alemi et al. (2017)). As discussed above the auto-correlated prior encourages an encoding in which temporally nearby latent states from the same trajectory tend to be close in the latent space, and the information bottleneck more generally encourages a limited dependence on $x _ { t }$ with $z _ { t }$ forming a compressed representation of the future trajectory as required for the action choice. ",
+        "bbox": [
+            174,
+            277,
+            825,
+            361
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.3 TRAINING A STUDENT POLICY FROM A SET OF EXAMPLES ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            378,
+            614,
+            392
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "When transferring knowledge from an expert policy to a student we would like the student to replicate the expert’s behavior in the full set of states plausibly visited by the expert. In our case, experts trained to reproduce single clips can be conceptualized as nonlinear feedback controllers around a nominal trajectory, and the manifold of states visited by experts can be thought of as a tube around that reference. We require the student to be able to operate successfully in and remain close to this tube even in the face of small perturbations. ",
+        "bbox": [
+            174,
+            404,
+            825,
+            488
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Formally, to ensure that the student retains expert robustness, we would like expert actions $\\mu _ { E } ( s )$ and student actions $\\mu _ { \\boldsymbol { \\theta } } ( s )$ to be close under a plausible (noisy) expert state distribution $\\rho _ { E }$ . A surrogate loss used in imitation learning as well as knowledge transfer is the quadratic loss between actions (Ross et al., 2011) (or activations Srinivas & Fleuret (2018)). ",
+        "bbox": [
+            173,
+            494,
+            825,
+            551
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b8c4e2d6c286736bba380699615bac37fa7f7a1b3c72e63e48a6d9eedb4e3c9f.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta } \\mathbb { E } _ { s \\sim \\rho _ { E } } [ ( \\mu _ { E } ( s ) - \\mu _ { \\theta } ( s ) ) ^ { 2 } ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            395,
+            555,
+            602,
+            579
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Behavioral cloning can refer to optimization of this objective, where $\\rho _ { E }$ is replaced with an empirical distribution of a set of state-action pairs $s$ . This works well if $s$ adequately covers the state distribution later experienced by the student. Anticipating and generating an appropriate set of states on which to train the student typically requires many rollouts and can thus be expensive. ",
+        "bbox": [
+            173,
+            593,
+            825,
+            650
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Since we are aiming to compress the behavior of thousands of experts we desire a computationally efficient method. We investigate two schemes that allow us to record the experts’ state-action mappings on a small-sample estimate of the experts’ state distributions and to then train the student via supervised learning. Both schemes are convenient to implement in a regular supervised learning pipeline and require neither querying many experts simultaneously (which limits scalability when dealing with thousands of experts) nor execution of the student at training time. ",
+        "bbox": [
+            173,
+            655,
+            825,
+            739
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Behavioral cloning from noisy rollouts The first approach amounts to simply gathering a number of noisy trajectories from the expert (either under a stochastic policy or with noise injection) while logging the optimal/mean action of the expert instead of the noisy action actually executed. A version of this is equivalent to the DART algorithm of Laskey et al. (2017). We then perform behavioral cloning from that data. ",
+        "bbox": [
+            174,
+            755,
+            825,
+            824
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Specifically, given an expert policy $\\pi _ { E }$ , let $\\mu _ { E } ( s )$ be the mean action of the expert in state $s$ . To obtain noisy rollouts, we run $\\pi _ { E } ^ { \\eta }$ , the expert with moderate action noise $( \\eta )$ to obtain a set of data $\\{ s _ { k } ^ { \\eta } , \\mu _ { k } \\} _ { 1 \\ldots K }$ , where $\\mu _ { k } = \\overset {  } { \\mu _ { E } ( s _ { k } ^ { \\eta } ) }$ . And we optimize the policy according to Eqn. 4, with the expectation over $s \\sim \\rho _ { E }$ being approximated by a sum over the set of state and expert-actions collected. While we expect this approach can work well, we do not expect it to be particularly efficient insofar as the expert may need to be executed for many rollouts. ",
+        "bbox": [
+            174,
+            830,
+            825,
+            888
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Linear-feedback policy cloning (LFPC) The second approach, which we refer to as linearfeedback policy cloning (LFPC), logs the action-state Jacobian as well as the expert action along a single nominal trajectory. The Jacobian can be used to construct a linear feedback controller which gives target actions in nearby perturbed states during training (described below). This approach is not intended to outperform behavioral cloning, as this should not be possible for arbitrary quantities of expert rollout data. Instead the motivation for LFPC is to do as well as behavioral cloning while using considerably fewer expert rollouts. ",
+        "bbox": [
+            173,
+            146,
+            825,
+            244
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As pointed out above, experts trained to reproduce single clips robustly can be thought of as nonlinear feedback controllers around this nominal trajectory. The nominal trajectory refers to the sequence of nominal state-action pairs $\\left\\{ s _ { t } ^ { \\star } , a _ { t } ^ { \\star } \\right\\} _ { 1 \\ldots T }$ obtained by executing $\\mu _ { E } ( s )$ recursively from an initial point $s _ { 0 } ^ { \\star }$ . Since expert behavior in our setting is well characterized by single nominal trajectories, we expect we can capture the relevant behavior of the expert by a linearization around the nominal trajectory3. ",
+        "bbox": [
+            173,
+            251,
+            825,
+            335
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Let δs be a small perturbation of the state and let J = dµE(s) |s be the Jacobian. Then ",
+        "bbox": [
+            171,
+            342,
+            753,
+            361
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/28abcf059e77b0da823ed0ee5b3bdfa3f08e2e984b2538487472efaa59e0330f.jpg",
+        "text": "$$\n\\mu _ { E } ( s + \\delta s ) = \\mu _ { E } ( s ) + \\pmb { J } \\delta s + O \\left( \\lVert \\delta s \\rVert ^ { 2 } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            366,
+            642,
+            386
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This linearization induces a linear-feedback-stabilized policy that at each time-step has a nominal action $a _ { t } ^ { \\star }$ , but also expects to be in state $s _ { t } ^ { \\star }$ , and correspondingly adjusts the nominal action with a linear correction based on discrepancy between the nominal and actual state at time $t$ : ",
+        "bbox": [
+            174,
+            396,
+            823,
+            439
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/47471dcbeb7064594a334bfe486ac19b03604aaa9728e8e276ac20d92df654ed.jpg",
+        "text": "$$\n\\mu _ { F B } ( s _ { t } ) = a _ { t } ^ { \\star } + { \\cal J } _ { t } ^ { \\star } ( s _ { t } - s _ { t } ^ { \\star } ) , ~ \\mathrm { w h e r e } ~ { \\cal J } _ { t } ^ { \\star } = \\left. \\frac { d \\mu _ { E } ( s ) } { d s } \\right| _ { s = s _ { t } ^ { \\star } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            294,
+            443,
+            705,
+            482
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We empirically validated that a linear feedback policy about the nominal trajectory of the expert can approximate the expert behavior reasonably well for clips we examine (see results Fig. 3). ",
+        "bbox": [
+            171,
+            492,
+            823,
+            522
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Above we presented the expert as a feedback controller operating in a tube around some nominal trajectory with states $s _ { 1 } ^ { \\star } , \\ldots , s _ { T } ^ { \\star }$ , actions $a _ { 1 } ^ { \\star } , \\ldots , a _ { T } ^ { \\star }$ , and Jacobians $J _ { 1 } ^ { \\star } , \\ldots , J _ { T } ^ { \\star }$ . We approximate $\\rho _ { E }$ with the distribution of states introduced by state perturbations around this nominal trajectory: ",
+        "bbox": [
+            176,
+            527,
+            825,
+            570
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b2497d666452f91e895ea08a906f5c7a91fd915a585f7109cb1711790affb2d6.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta } \\frac { 1 } { T } \\sum _ { i } \\mathbb { E } _ { \\delta s _ { i } \\sim \\Delta ( s ) } [ \\| \\mu _ { E } ( s _ { i } + \\delta s _ { i } ) - \\mu _ { \\theta } ( s _ { i } + \\delta s _ { i } ) \\| ^ { 2 } ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            312,
+            575,
+            686,
+            612
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "However, this objective still requires expert evaluations at the perturbed states. Using the linearization described above we can replace the expert action $\\mu _ { E } ( s + \\delta s )$ with the Jacobian-based linearfeedback policy $\\mu _ { F B } ( s + \\delta s )$ , which is available offline. This yields the LFPC objective: ",
+        "bbox": [
+            173,
+            616,
+            825,
+            659
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d84cb7b54f9d2b5956c39014e675c80cd6a2659b1e17dc46aa34037f332908a7.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta } \\frac { 1 } { T } \\sum _ { i } \\mathbb { E } _ { \\delta s _ { i } \\sim \\Delta ( s ) } [ | | \\mu _ { \\theta } ( s _ { i } ^ { \\star } + \\delta s _ { i } ) - a _ { i } ^ { \\star } - J _ { i } ^ { \\star } \\delta s _ { i } | | _ { 2 } ^ { 2 } ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            664,
+            679,
+            700
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "One potentially important choice is the perturbation distribution $\\Delta ( s )$ . Ideally, we would like $\\Delta ( s )$ to be the state-dependent distribution induced by physically plausible transitions, but estimating this distribution may require potentially expensive rollouts which we are trying to avoid. A cheaper object to estimate is the stationary transition noise distribution induced by noisy actions, which can be efficiently approximated from a small number of trajectories. Empirically, we found the objective 8 to be relatively robust to some variations in $\\Delta$ , and we use a fixed marginal distribution for all clips. ",
+        "bbox": [
+            173,
+            713,
+            825,
+            797
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Objective 8 bears interesting similarities to approaches such as denoising autoencoders (Vincent et al., 2008), where networks can learn to ignore local noise perturbations on inputs sampled from a high-dimensional noise distribution. Further, Mordatch et al. (2015) successfully distill feedback policies obtained from a planner. One question left open by this latter work is that of how much data might be required. Empirically we show in the experiments below that the augmented objective 8 can produce the desired robustness even from a very limited set of states. ",
+        "bbox": [
+            174,
+            803,
+            825,
+            888
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/5e7a7857baecce1901177e9515c069361df513c0963b1516e980158d70530333.jpg",
+        "image_caption": [
+            "Figure 3: Comparisons of trajectory rollouts for 4 reference behaviors for the nominal trajectory and at varying noise levels. Note that the score is determined by similarity to motion-capture reference and the expert may be slightly suboptimal so slight improvements on the expert may arise by chance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            89,
+            818,
+            353
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "There are multiple, relevant perspectives on LFPC. From one perspective, LFPC amounts to a data augmentation method. From another vantage, the approach attempts to match the mean action as well as the Jacobian at the set of relevant behavioral states, here sampled along the nominal trajectory. In settings where expert behavior is more diverse or multimodal, LFPC should be applied to states which representatively cover relevant behavioral modes or perhaps are expanded backwards from goal states (roughly similar to the procedure used to expand LQR-trees by Tedrake 2009). Explicit Jacobian matching has been proposed elsewhere, for example in Czarnecki et al. (2017). See appendix C for further disambiguation relative to other approaches. ",
+        "bbox": [
+            174,
+            438,
+            825,
+            551
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To train our Neural Probabilistic Motor Primitive architecture using LFPC we can adapt the objective in Eqn. 3 as follows: ",
+        "bbox": [
+            173,
+            556,
+            821,
+            585
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/976cd9de54dc61807454dd3073ddf13fa5488d240e8da367f3661d785308940e.jpg",
+        "text": "$$\n\\mathbb { E } _ { \\delta s , q } \\left[ \\sum _ { t = 1 } ^ { T } \\log \\pi ( a _ { t } + J _ { t } \\delta s _ { t } | s _ { t } + \\delta s _ { t } , z _ { t } ) + \\beta \\big ( \\log p _ { z } ( z _ { t } | z _ { t - 1 } ) - \\log q ( z _ { t } | z _ { t - 1 } , x _ { t } + \\delta x _ { t } ) \\big ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            179,
+            590,
+            797,
+            633
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $\\delta { s } _ { t }$ are i.i.d. perturbations drawn from suitable perturbation distribution $\\Delta$ and $\\delta \\boldsymbol { x } _ { t }$ is the concatenation of $[ \\delta s _ { t } , \\delta s _ { t + 1 } , . . . , \\delta s _ { t + K } ]$ . ",
+        "bbox": [
+            174,
+            637,
+            825,
+            667
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            685,
+            326,
+            702
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.1 VALIDATION: TRANSFER OF SINGLE-BEHAVIOR POLICIES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            718,
+            609,
+            732
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To ground our results in a simple setting, we begin with transfer of a single-skill, time-indexed policy from one network to another. We compare the performance of various time-indexed policies for each of the experts depicted in Fig. 1. We compare the original expert policy, an open-loop action sequence along the experts nominal (i.e. mean) trajectory, a linear feedback policy along the expert nominal trajectory, as well as the network trained to match the linear-feedback behavior (LFPC). In addition we compare to policies trained from 100, 200, 500 or 1000 trajectories with behavioral cloning. We compare each approach with no action noise, small action noise, and moderate action noise (noise is i.i.d. normal per actuator with standard deviation magnitude .05 and .1 respectively, for action ranges normalized to $[ - 1 , 1 ] ,$ ). Note that, open loop control almost always fails if the state is perturbed by even a small $\\epsilon$ (though perhaps surprisingly, the backflip can almost be executed open loop due to limited ground contact). Remarkably, LFPC with a single trajectory performs on par with behavioral cloning based on hundreds of trajectories (see Fig. 3). For additional validation, see appendix D. ",
+        "bbox": [
+            174,
+            742,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/21d8691d31d8d6a16a6ac2fd7667092303bc04f74dda5d129951cef9bfaf5dd8.jpg",
+        "image_caption": [
+            "Figure 4: Performance relative to expert policies for trained neural probabilistic motor primitive models. Performance of model variations are compared on training and testing data. We compare models trained using cloning with 100 trajectories per expert for different levels of regularization, using a smaller latent space of dimension 20 rather than 60 in all other experiments, as well as LFPC. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            214,
+            102,
+            795,
+            352
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": ".2 CORE RESULTS: COMPRESSING THOUSANDS OF EXPERTS ",
+        "text_level": 1,
+        "bbox": [
+            187,
+            454,
+            606,
+            467
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Having validated that single skills can be transferred, we next consider how well we can compress behaviors of the 2707 experts in our training set into the neural probabilistic motor primitive architecture. Assessing the models using the action-reconstruction loss is not very intuitive since it does not capture model behavior in the environment. Instead we report a more relevant measure based on expert imitation. Here we encode an expert trajectory into a sequence of latent variables and then execute the policy in the environment conditioned on this sequence. Note that this approach is openloop with respect to the latents while being closed-loop with respect to state. We can then compare the performance of the trained system against experts on training and held-out clips according to the tracking reward used to train the experts originally. To account for different expert reward scales we report performance relative to the expert policy. Importantly, that this approach works is itself a partial validation of the premise of this work, insofar as open-loop execution of action sequences usually trivially fails with minor perturbations. The trained neural probabilistic motor primitive system can execute behaviors conditioned on an open-loop noisy latent variable trajectory, implying that the decoder has learned to stabilize the body during latent-conditioned behavior. ",
+        "bbox": [
+            174,
+            479,
+            825,
+            674
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "There are a few key takeaways from the comparisons we have run (see Fig. 4). Most saliently cloning based on 100 trajectories from each expert with a medium regularization value $( \\beta = 0 . 1 )$ works best. LFPC with comparable parameters works less well here, but has qualitatively fairly similar performance. Our ablations show that regularization and a large latent space are important for good results. We also set the autoregressive parameter $\\alpha = 0$ (.95 in other runs), making the latent variables i.i.d.. This hurts performance, validating our choice of prior.4 ",
+        "bbox": [
+            174,
+            680,
+            825,
+            763
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.3 ANALYSIS OF THE TRAINED MODEL ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            781,
+            460,
+            795
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We have no expectation that trajectories well outside the training distribution are likely to be either representable by the encoder or executable by the decoder. Nevertheless, when one-shot imitation of a trajectory fails, a natural question is whether the decoder is incapable of expressing the desired actions, or the encoder fails to encode the trajectory in such a way that the decoder will produce it. ",
+        "bbox": [
+            174,
+            808,
+            825,
+            863
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/e1b92e17a4ed8432b233f2b136d87bbb1a350c2d3caffd6e38c50aefdef8a308.jpg",
+        "image_caption": [
+            "Figure 5: These panels consist of visualizations of the PCA latent space with comparisons in this space between one-shot latent-variable sequences and optimized latent variable sequences for various behaviors: A. Run B. Backwards walking C. Jumping. Running executes well based on the one-shot trajectory so serves as a reference for which optimization is not noticeably different. Walking backwards and jumping one-shot imitations fail, but are noticeably improved by optimization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            217,
+            77,
+            787,
+            156
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We propose an analysis to distinguish this for borderline cases. For held out trajectories that yield unsatisfying performance on one-shot imitation, we can simply optimize directly: ",
+        "bbox": [
+            173,
+            262,
+            821,
+            291
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/199c4df05e4ce5ba76030a922a4a23dbd8be50f7ebd77cca94e7b60ab113e920.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { z _ { 1 } . . . z _ { T } } \\sum _ { t = 1 } ^ { T } | | \\mu _ { \\boldsymbol { \\theta } } ( s _ { t } , z _ { t } ) - a _ { t } ^ { \\star } | | _ { 2 } ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            297,
+            599,
+            342
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "where $\\mu _ { \\theta }$ is the decoder mean. Empirically we see that this optimization meaningfully improves the executed behavior, and we visualize the shift in a three-dimensional space given by the first three principal components in Fig. 5. ",
+        "bbox": [
+            174,
+            348,
+            825,
+            391
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We exhibit three examples where we visualize the original latent trajectory as well as the optimized latent trajectory. Performance is significantly improved (see supplementary video), showing the latent space can represent behaviors for which one-shot imitation fails. However execution remains imperfect suggesting that while much of the fault may lie with the encoder, the decoder still may be slightly undertrained on these relatively rare behavior categories. Quantitatively, among a larger set of clips with less than $50 \\%$ relative expert performance for one-shot imitation we found that optimization as described above improved median relative expert performance from $43 \\%$ to $78 \\%$ . ",
+        "bbox": [
+            173,
+            397,
+            825,
+            496
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Other exploratory probes of the module suggest that it is possible in certain cases to obtain seamless transitioning between behaviors by concatenating latent-variable trajectories and running the policy conditioned on this sequence (e.g. in order to perform a sequence of turns). See additional supplementary video. ",
+        "bbox": [
+            174,
+            502,
+            825,
+            558
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Reuse of motor primitive module Finally, we experimented with reuse of the decoder as a motor primitive module. We treat the latent space as a new custom action space and train a new high-level (HL) policy to operate in this space. At each time-step the high-level policy outputs a latent-variable ",
+        "bbox": [
+            173,
+            574,
+            826,
+            617
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/64f8148d800dc134663ee5a1997292e43576ba9acf8a4419c1d584c2b65604b2.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            645,
+            478,
+            806
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "(a) Median return value across 10 seeds for the goto-target task vs learner steps. Compared to a very weakly regularized module $( \\beta ~ = ~ 0 . 0 0 1 )$ ), more regularized motor primitives modules both trained faster and achieved higher final performance. ",
+        "bbox": [
+            191,
+            818,
+            485,
+            881
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/b7b9c3e9b1c45beb1656f2c4740036f4252345f4c4908840e280484b1144511d.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            519,
+            645,
+            800,
+            806
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "(b) Our model is able to track the target speed accurately. Shown here are target speed and actual speed in the egocentric forward direction for three episodes. The reward function is a Gaussian centered at the target speed. The shaded region corresponds to $\\pm$ one standard deviation. ",
+        "bbox": [
+            513,
+            818,
+            808,
+            893
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure 6: Reuse of neural probabilistic motor primitive modules. ",
+        "bbox": [
+            284,
+            905,
+            710,
+            920
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "$z _ { t }$ . The actual action is then given by the motor primitive module $p ( a _ { t } | s _ { t } , z _ { t } )$ . For training we used SVG(0) (Heess et al., 2015) with the Retrace off-policy correction for learning the Q-function (Munos et al., 2016). ",
+        "bbox": [
+            178,
+            103,
+            821,
+            145
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A natural locomotion task that can challenge the motor module is a task which requires abrupt, frequently redirected movement with sharp turns and changes of speed. To implement this we provide the higher-level controller with a target that is constant until the humanoid is near it for a few timesteps at which point it randomly moves to another nearby location. While no single task will comprehensively probe the module, performing well in this task demands a wide range of quick locomotion behavior. With only a sparse task reward, the HL-controller can learn to control the body through the learned primitive space, and it produces rather humanlike task-directed movement. We observed that more regularized motor primitive modules had more stable initial behavior when connected to the untrained high-level controller (i.e. were less likely to fall at the beginning of training). Compared to a very weakly regularized module $( \\beta = 0 . 0 0 1 )$ , more regularized motor primitives modules both trained faster and achieved higher final performance (see Fig. 6a). We also investigated a go-to-target task with bumpy terrain that is unobserved by the agent. The fact that our model can learn to solve this task demonstrates its robustness to unseen perturbations for which the motor primitive module was not explicitly trained. In another experiment we investigated a task in which the agent has to move at a random, changing target speed. This requires transitions between qualitatively different locomotion behavior such as walking, jogging, and running (see Fig. 6b). See an extended video of these experiments. In a final reuse experiment, we consider an obstacle course requiring the agent to jump across gaps (as in Merel et al. (2018)). We were able to solve this challenging task with a high-level controller that operated using egocentric visual inputs (see the main supplementary video). ",
+        "bbox": [
+            174,
+            154,
+            825,
+            429
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We emphasize a few points about these results to impact their importance: (1) Using a pretrained neural probabilistic motor primitives module, new controllers can be trained effectively from scratch on sparse reward tasks, (2) the resulting movements are visually rather humanlike without additional constraints implying that the learned embedding space is well structured, and (3) the module enables fairly comprehensive and smooth coverage for the purposes of physics-based control. ",
+        "bbox": [
+            176,
+            436,
+            823,
+            507
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            545,
+            310,
+            560
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper we have described approaches for transfer and compression of control policies. We have exhibited a motor primitive module that learns to represent and execute motor behaviors for control of a simulated humanoid body. Using either a variant of behavioral cloning or linear feedback policy cloning we can train the neural probabilistic motor primitive sytem to perform robust one-shotimitation, and with the latter we can use relatively restricted data consisting of only single rollouts from each expert. While LFPC did not work quite as well in the full-scale model as cloning from noisy rollouts, we consider it remarkable that it is possible in our setting to transfer expert behavior using a single rollout. We believe LFPC holds promise insofar as it may be useful in settings where rollouts are costly to obtain (e.g. adapted to real-world robotic applications), and there is room for further improvement as we did not carefully tune certain parameters, most saliently the marginal noise distribution $\\Delta$ . ",
+        "bbox": [
+            174,
+            587,
+            825,
+            739
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The resulting neural probabilistic motor primitive module is interpretable and reusable. We are optimistic that this kind of architecture could serve as a basis for further continual learning of motor skills. This work has been restricted to motor behaviors which do not involve interactions with objects and where a full set a of behaviors are available in advance. Meaningful extensions of this work may attempt to greatly enrich the space of behaviors or demonstrate how to perform continual learning and reuse of new skills. ",
+        "bbox": [
+            174,
+            747,
+            825,
+            830
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            866,
+            326,
+            877
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The data used in this project was obtained from mocap.cs.cmu.edu. The database was created with funding from NSF EIA-0196217. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alexander A Alemi, Ian Fischer, Joshua V Dillon, and Kevin Murphy. Deep variational information bottleneck. International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            174,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael Athans. The role and use of the stochastic linear-quadratic-gaussian problem in control system design. IEEE transactions on automatic control, 16(6):529–552, 1971. ",
+        "bbox": [
+            173,
+            162,
+            820,
+            191
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Trapit Bansal, Jakub Pachocki, Szymon Sidor, Ilya Sutskever, and Igor Mordatch. Emergent complexity via multi-agent competition. International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            173,
+            199,
+            821,
+            242
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "E Bizzi, VCK Cheung, A d’Avella, P Saltiel, and Matthew Tresch. Combining modules for movement. Brain research reviews, 57(1):125–133, 2008. ",
+        "bbox": [
+            171,
+            251,
+            823,
+            281
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nuttapong Chentanez, Matthias Muller, Miles Macklin, Viktor Makoviychuk, and Stefan Jeschke. ¨ Physics-based motion capture imitation with deep reinforcement learning. In Proceedings of the 11th Annual International Conference on Motion, Interaction, and Games, pp. 1. ACM, 2018. ",
+        "bbox": [
+            174,
+            287,
+            825,
+            332
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wojciech M Czarnecki, Simon Osindero, Max Jaderberg, Grzegorz Swirszcz, and Razvan Pascanu. Sobolev training for neural networks. In Advances in Neural Information Processing Systems, pp. 4281–4290, 2017. ",
+        "bbox": [
+            174,
+            339,
+            823,
+            382
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kai Ding, Libin Liu, Michiel Van de Panne, and KangKang Yin. Learning reduced-order feedback policies for motion skills. In Proceedings of the 14th ACM SIGGRAPH/Eurographics Symposium on Computer Animation, pp. 83–92. ACM, 2015. ",
+        "bbox": [
+            174,
+            390,
+            823,
+            434
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yan Duan, Marcin Andrychowicz, Bradly Stadie, OpenAI Jonathan Ho, Jonas Schneider, Ilya Sutskever, Pieter Abbeel, and Wojciech Zaremba. One-shot imitation learning. In Advances in neural information processing systems, pp. 1087–1098, 2017. ",
+        "bbox": [
+            176,
+            441,
+            823,
+            486
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tommaso Furlanello, Zachary C Lipton, Michael Tschannen, Laurent Itti, and Anima Anandkumar. Born again neural networks. arXiv preprint arXiv:1805.04770, 2018. ",
+        "bbox": [
+            169,
+            493,
+            823,
+            522
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael Graziano. The organization of behavioral repertoire in motor cortex. Annu. Rev. Neurosci., 29:105–134, 2006. ",
+        "bbox": [
+            171,
+            530,
+            823,
+            560
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Heess, Gregory Wayne, David Silver, Tim Lillicrap, Tom Erez, and Yuval Tassa. Learning continuous control policies by stochastic value gradients. In Advances in Neural Information Processing Systems, pp. 2944–2952, 2015. ",
+        "bbox": [
+            173,
+            568,
+            823,
+            611
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Heess, Srinivasan Sriram, Jay Lemmon, Josh Merel, Greg Wayne, Yuval Tassa, Tom Erez, Ziyu Wang, Ali Eslami, Martin Riedmiller, et al. Emergence of locomotion behaviours in rich environments. arXiv preprint arXiv:1707.02286, 2017. ",
+        "bbox": [
+            173,
+            619,
+            823,
+            662
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015. ",
+        "bbox": [
+            173,
+            670,
+            823,
+            700
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David H. Jacobson and David Q. Mayne. Differential Dynamic Programming. Elsevier, 1970. ",
+        "bbox": [
+            171,
+            708,
+            790,
+            724
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. International Conference on Learning Representations, 2015. ",
+        "bbox": [
+            173,
+            732,
+            820,
+            761
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Max Welling. Auto-encoding variational bayes. International Conference on Learning Representations, 2013. ",
+        "bbox": [
+            173,
+            768,
+            823,
+            799
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael Laskey, Jonathan Lee, Roy Fox, Anca Dragan, and Ken Goldberg. Dart: Noise injection for robust imitation learning. In Conference on Robot Learning, pp. 143–156, 2017. ",
+        "bbox": [
+            174,
+            806,
+            821,
+            837
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Libin Liu and Jessica Hodgins. Learning basketball dribbling skills using trajectory optimization and deep reinforcement learning. ACM Transactions on Graphics (TOG), 37(4):142, 2018. ",
+        "bbox": [
+            174,
+            843,
+            823,
+            873
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Libin Liu, KangKang Yin, Michiel van de Panne, Tianjia Shao, and Weiwei Xu. Sampling-based contact-rich motion control. In ACM Transactions on Graphics (TOG), volume 29, pp. 128. ACM, 2010. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Mayne. A second-order gradient method for determining optimal trajectories of non-linear discrete-time systems. International Journal of Control, 3(1):85–95, 1966. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Franziska Meier and Stefan Schaal. A probabilistic representation for dynamic movement primitives. arXiv preprint arXiv:1612.05932, 2016. ",
+        "bbox": [
+            169,
+            142,
+            823,
+            171
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Josh Merel, Yuval Tassa, Sriram Srinivasan, Jay Lemmon, Ziyu Wang, Greg Wayne, and Nicolas Heess. Learning human behaviors from motion capture by adversarial imitation. arXiv preprint arXiv:1707.02201, 2017. ",
+        "bbox": [
+            173,
+            181,
+            826,
+            224
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Josh Merel, Arun Ahuja, Vu Pham, Saran Tunyasuvunakool, Siqi Liu, Dhruva Tirumala, Nicolas Heess, and Greg Wayne. Hierarchical visuomotor control of humanoids. arXiv preprint arXiv:1811.09656, 2018. ",
+        "bbox": [
+            173,
+            234,
+            825,
+            277
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Igor Mordatch, Kendall Lowrey, Galen Andrew, Zoran Popovic, and Emanuel V Todorov. Interactive control of diverse complex characters with neural networks. In Advances in Neural Information Processing Systems, pp. 3132–3140, 2015. ",
+        "bbox": [
+            173,
+            286,
+            825,
+            330
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jun Morimoto and Christopher G Atkeson. Minimax differential dynamic programming: An application to robust biped walking. In Advances in neural information processing systems, pp. 1563–1570, 2003. ",
+        "bbox": [
+            169,
+            340,
+            823,
+            382
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Remi Munos, Tom Stepleton, Anna Harutyunyan, and Marc Bellemare. Safe and efficient off-policy ´ reinforcement learning. In Advances in Neural Information Processing Systems, pp. 1054–1062, 2016. ",
+        "bbox": [
+            174,
+            392,
+            825,
+            435
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Gerhard Neumann, Christian Daniel, Alexandros Paraschos, Andras Kupcsik, and Jan Peters. Learning modular policies for robotics. Frontiers in computational neuroscience, 8:62, 2014. ",
+        "bbox": [
+            173,
+            445,
+            821,
+            476
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alexandros Paraschos, Christian Daniel, Jan R Peters, and Gerhard Neumann. Probabilistic movement primitives. In Advances in neural information processing systems, pp. 2616–2624, 2013. ",
+        "bbox": [
+            173,
+            484,
+            821,
+            515
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Emilio Parisotto, Jimmy Lei Ba, and Ruslan Salakhutdinov. Actor-mimic: Deep multitask and transfer reinforcement learning. arXiv preprint arXiv:1511.06342, 2015. ",
+        "bbox": [
+            173,
+            523,
+            823,
+            554
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xue Bin Peng, Glen Berseth, KangKang Yin, and Michiel Van De Panne. Deeploco: Dynamic locomotion skills using hierarchical deep reinforcement learning. ACM Transactions on Graphics (TOG), 36(4):41, 2017. ",
+        "bbox": [
+            173,
+            563,
+            823,
+            606
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xue Bin Peng, Pieter Abbeel, Sergey Levine, and Michiel van de Panne. Deepmimic: Example-guided deep reinforcement learning of physics-based character skills. arXiv preprint arXiv:1804.02717, 2018. ",
+        "bbox": [
+            173,
+            616,
+            823,
+            660
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In Proceedings of the 31st International Conference on International Conference on Machine Learning - Volume 32, ICML’14, pp. II–1278– II–1286. JMLR.org, 2014. URL http://dl.acm.org/citation.cfm?id $=$ 3044805. 3045035. ",
+        "bbox": [
+            173,
+            669,
+            825,
+            739
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Stephane Ross, Geoffrey Gordon, and Drew Bagnell. A reduction of imitation learning and struc- ´ tured prediction to no-regret online learning. In Proceedings of the fourteenth international conference on artificial intelligence and statistics, pp. 627–635, 2011. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            794
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Andrei A Rusu, Sergio Gomez Colmenarejo, Caglar Gulcehre, Guillaume Desjardins, James Kirkpatrick, Razvan Pascanu, Volodymyr Mnih, Koray Kavukcuoglu, and Raia Hadsell. Policy distillation. arXiv preprint arXiv:1511.06295, 2015. ",
+        "bbox": [
+            173,
+            803,
+            823,
+            847
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Stefan Schaal, Jan Peters, Jun Nakanishi, and Auke Ijspeert. Learning movement primitives. In International Symposium on Robotics Research, (ISRR), 2003. ",
+        "bbox": [
+            171,
+            856,
+            823,
+            885
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In International Conference on Machine Learning, pp. 1889–1897, 2015. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Suraj Srinivas and Franc¸ois Fleuret. Knowledge transfer with jacobian matching. CoRR, abs/1803.00443, 2018. URL http://arxiv.org/abs/1803.00443. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yuval Tassa, Tom Erez, and Emanuel Todorov. Synthesis and stabilization of complex behaviors through online trajectory optimization. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp. 4906–4913. IEEE, 2012. ",
+        "bbox": [
+            176,
+            142,
+            821,
+            185
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yuval Tassa, Nicolas Mansard, and Emo Todorov. Control-limited differential dynamic programming. In Robotics and Automation (ICRA), 2014 IEEE International Conference on, pp. 1168– 1175. IEEE, 2014. ",
+        "bbox": [
+            174,
+            195,
+            826,
+            237
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Russ Tedrake. LQR-trees: Feedback motion planning on sparse randomized trees. 2009. ",
+        "bbox": [
+            171,
+            247,
+            754,
+            263
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yee Whye Teh, Victor Bapst, Wojciech M Czarnecki, John Quan, James Kirkpatrick, Raia Hadsell, Nicolas Heess, and Razvan Pascanu. Distral: Robust multitask reinforcement learning. In Advances in Neural Information Processing Systems, pp. 4499–4509, 2017. ",
+        "bbox": [
+            174,
+            272,
+            825,
+            315
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Emanuel Todorov and Zoubin Ghahramani. Unsupervised learning of sensory-motor primitives. In Engineering in Medicine and Biology Society, 2003. Proceedings of the 25th Annual International Conference of the IEEE, volume 2, pp. 1750–1753. IEEE, 2003. ",
+        "bbox": [
+            176,
+            325,
+            823,
+            368
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp. 5026– 5033. IEEE, 2012. ",
+        "bbox": [
+            174,
+            378,
+            823,
+            420
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Pascal Vincent, Hugo Larochelle, Yoshua Bengio, and Pierre-Antoine Manzagol. Extracting and composing robust features with denoising autoencoders. In Proceedings of the 25th international conference on Machine learning, pp. 1096–1103. ACM, 2008. ",
+        "bbox": [
+            174,
+            431,
+            825,
+            474
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ziyu Wang, Josh S Merel, Scott E Reed, Nando de Freitas, Gregory Wayne, and Nicolas Heess. Robust imitation of diverse behaviors. In Advances in Neural Information Processing Systems, pp. 5320–5329, 2017. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            526
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "APPENDICES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            555,
+            282,
+            570
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A MOTION CAPTURE EXPERTS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            588,
+            442,
+            604
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The approach we use for producing experts is detailed more fully in Merel et al. (2018). In short, this approach for producing experts largely follows Peng et al. (2018). We took the energy function proposed in SAMCON (Liu et al., 2010), and use it as a per timestep reward to train a time-indexed policy that tracks/imitates a motion capture reference clip (Peng et al., 2018). As proposed in Merel et al. (2017); Peng et al. (2018), episodes are initialized to poses throughout the motion capture reference and episodes are early-terminated when the character falls. Here we use an off-policy RL algorithm, SVG(0) (Heess et al., 2015) with Retrace (Munos et al., 2016). As done in Merel et al. (2017); Peng et al. (2018) and elsewhere, we train stochastic policies and use the mean (i.e. noiseless) action as the expert policy. ",
+        "bbox": [
+            173,
+            619,
+            825,
+            746
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B ARCHITECTURE AND TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            767,
+            547,
+            782
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The decoder $p ( a _ { t } | s _ { t } , z _ { t } )$ in our experiments was a MLP with three layers with 1024 hidden units taking as input the concatenation of state $s _ { t }$ and latent variable $z _ { t }$ . The decoder output distribution is a multivariate Gaussian with fixed standard deviation of 0.1 (action values are normalized to $[ - 1 , 1 ] ,$ ). We found that fixing the standard deviation made it significantly easier to prevent overfitting. Note that in this setting varying the $\\beta$ parameter is equivalent to varying the fixed output variance (up to a constant). The encoder $q ( z _ { t } | \\boldsymbol { z } _ { t - 1 } , \\boldsymbol { x } _ { t } )$ in our experiments was also an MLP with two layers of 1024 hidden units each. The inputs were simply concatenated at the input. The encoder output distribution was a multivariate Gaussian with learnt variance. In most of our experiments, we used a 60-dimensional latent space. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We used the reparametrization trick (Kingma & Welling, 2013; Rezende et al., 2014) to train the model and used stochastic gradient descent with ADAM (Kingma & Ba, 2015) with a learning rate of 0.0001. In the case of models trained on 100 trajectories per expert we used minibatches of 512 subsequences of length 30. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For LFPC we sampled 32 subsequences of length 30 and produced 5 perturbed state sequences per subsequence. In preliminary experiments the length of the subsequences did not have a major impact on model performance. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            208
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "C RELATIONSHIP TO OTHER KNOWLEDGE TRANSFER IDEAS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            229,
+            684,
+            246
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Firstly, we note that the emphasis of the proposal in this work is to match the responsivity of the expert policy in a neighborhood around each state. This is distinct from activation matching or KL matching where the emphasis is on matching the action/activation distribution for a particular state (Rusu et al., 2015; Teh et al., 2017). Secondly, we emphasize that the kind of robust knowledge transfer we discuss here is distinct from that which is seen to be important in other settings. For example Srinivas & Fleuret (2018) provide a line of reasoning that involves training a student system to match the exact activations of a teacher in the presence of perturbations on the student inputs. This logic is sound in the setting of large-scale vision systems. However in the context of control policies, this would look like: ",
+        "bbox": [
+            173,
+            260,
+            825,
+            386
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6210f45e8052728b91a4a709ce2c0ad6960166fa481efcadd12d60cff41e4975.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta } \\sum _ { s \\in S ^ { \\star } } \\mathbb { E } _ { \\delta s \\sim \\Delta ( s ) } [ ( \\mu _ { E } ( s ) - \\mu _ { \\theta } ( s + \\delta s ) ) ^ { 2 } ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            410,
+            645,
+            445
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "This essentially means that the student policy is learning to “blindly” reproduce the action of the expert exactly, despite input perturbations. While this is well motivated if the noise is thought to be orthogonal to the proper functioning of the system, this is a very bad idea for control, where you need to pay close attention to small input perturbations. Technically, this amounts to setting the local feedback to zero, and behaving in a sort of open-loop-like fashion. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            529
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "D VISUALIZATION OF STATIONARY POLICY BEHAVIOR ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            549,
+            638,
+            565
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Locomotion behavior is, at least in the simplest case roughly a limit cycle. In an additional experiment to test LFPC we gathered three gait cycles of running behavior and performed LFPC. Note that here the student policy need not be time-indexed even when the demonstrations were time-indexed. This restricted case shows striking generalization in the presence of noise (see Fig. A.1 and also see main supplementary video). ",
+        "bbox": [
+            173,
+            579,
+            825,
+            650
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/dfcdc7f26b0d7f77ba20247a5d80cda6f4765a026626458e74274d2edd13a3e8.jpg",
+        "image_caption": [
+            "Figure A.1: Dimensionality reduction (PCA) performed on set of poses obtained from noisy rollouts of the stationary cloned policy (blue). The limited reference data originating from a time-indexed policy has been projected into the same space (green). Observe that the rollouts are considerably noisier and consistently deviate from the reference trajectory, nevertheless the cloned-policy trajectories return to the limit cycle. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            669,
+            483,
+            832
+        ],
+        "page_idx": 13
+    }
+]

parse/train/BJlrF24twB/BJlrF24twB.md

@@ -0,0 +1,623 @@
+# BACKPACK: PACKING MORE INTO BACKPROP
+
+Felix Dangel∗ University of Tuebingen fdangel@tue.mpg.de
+
+Frederik Kunstner∗ University of Tuebingen kunstner@cs.ubc.ca
+
+# Philipp Hennig
+
+University of Tuebingen and MPI for Intelligent Systems, Tuebingen ph@tue.mpg.de
+
+# ABSTRACT
+
+Automatic differentiation frameworks are optimized for exactly one thing: computing the average mini-batch gradient. Yet, other quantities such as the variance of the mini-batch gradients or many approximations to the Hessian can, in theory, be computed efficiently, and at the same time as the gradient. While these quantities are of great interest to researchers and practitioners, current deep-learning software does not support their automatic calculation. Manually implementing them is burdensome, inefficient if done na¨ıvely, and the resulting code is rarely shared. This hampers progress in deep learning, and unnecessarily narrows research to focus on gradient descent and its variants; it also complicates replication studies and comparisons between newly developed methods that require those quantities, to the point of impossibility. To address this problem, we introduce BACKPACK1, an efficient framework built on top of PYTORCH, that extends the backpropagation algorithm to extract additional information from first- and second-order derivatives. Its capabilities are illustrated by benchmark reports for computing additional quantities on deep neural networks, and an example application by testing several recent curvature approximations for optimization.
+
+# 1 INTRODUCTION
+
+The success of deep learning and the applications it fuels can be traced to the popularization of automatic differentiation frameworks. Packages like TENSORFLOW (Abadi et al., 2016), CHAINER (Tokui et al., 2015), MXNET (Chen et al., 2015), and PYTORCH (Paszke et al., 2019) provide efficient implementations of parallel, GPU-based gradient computations to a wide range of users, with elegant syntactic sugar.
+
+However, this specialization also has its shortcomings: it assumes the user only wants to compute gradients or, more precisely, the average of gradients across a mini-batch of examples. Other quantities can also be computed with automatic differentiation at a comparable cost or minimal overhead to the gradient backpropagation pass; for example, approximate second-order information or the variance of gradients within the batch. These quantities are valuable to understand the geometry of deep neural networks, for the identification of free parameters, and to push the development of more efficient optimization algorithms. But researchers who want to investigate their use face a chickenand-egg problem: automatic differentiation tools required to go beyond standard gradient methods are not available, but there is no incentive for their implementation in existing deep-learning software as long as no large portion of the users need it.
+
+Second-order methods for deep learning have been continuously investigated for decades (e.g., Becker & Le Cun, 1989; Amari, 1998; Bordes et al., 2009; Martens & Grosse, 2015). But still, the standard optimizers used in deep learning remain some variant of stochastic gradient descent (SGD); more complex methods have not found wide-spread, practical use. This is in stark contrast to domains like convex optimization and generalized linear models, where second-order methods are the default. There may of course be good scientific reasons for this difference; maybe second-order methods do not work well in the (non-convex, stochastic) setting of deep learning. And the computational cost associated with the high dimensionality of deep models may offset their benefits. Whether these are the case remains somewhat unclear though, because a much more direct road-block is that these methods are so complex to implement that few practitioners ever try them out.
+
+Recent approximate second-order methods such as KFAC (Martens & Grosse, 2015) show promising results, even on hard deep learning problems (Tsuji et al., 2019). Their approach, based on the earlier work of Schraudolph (2002), uses the structure of the network to compute approximate secondorder information in a way that is similar to gradient backpropagation. This work sparked a new line of research to improve the second-order approximation (Grosse & Martens, 2016; Botev et al., 2017; Martens et al., 2018; George et al., 2018). However, all of these methods require low-level applications of automatic differentiation to compute quantities other than the averaged gradient. It is a daunting task to implement them from scratch. Unless users spend significant time familiarizing themselves with the internals of their software tools, the resulting implementation is often inefficient, which also puts the original usability advantage of those packages into question. Even motivated researchers trying to develop new methods, who need not be expert software developers, face this problem. They often end up with methods that cannot compete in runtime, not necessarily because the method is inherently bad, but because the implementation is not efficient. New methods are also frequently not compared to their predecessors and competitors because they are so hard to reproduce. Authors do not want to represent the competition in an unfair light caused by a bad implementation.
+
+Another example is offered by a recent string of research to adapt to the stochasticity induced by mini-batch sampling. An empirical estimate of the (marginal) variance of the gradients within the batch has been found to be theoretically and practically useful for adapting hyperparameters like learning rates (Mahsereci & Hennig, 2017) and batch sizes (Balles et al., 2017), or regularize firstorder optimization (Le Roux et al., 2007; Balles & Hennig, 2018; Katharopoulos & Fleuret, 2018). To get such a variance estimate, one simply has to square, then sum, the individual gradients after the backpropagation, but before they are aggregated to form the average gradient. Doing so should have negligible cost in principle, but is programmatically challenging in the standard packages.
+
+Members of the community have repeatedly asked for such features2 but the established automatic differentiation frameworks have yet to address such requests, as their focus has been—rightly—on improving their technical backbone. Features like those outlined above are not generally defined for arbitrary functions, but rather emerge from the specific structure of machine learning applications. General automatic differentiation frameworks can not be expected to serve such specialist needs. This does not mean, however, that it is impossible to efficiently realize such features within these frameworks: In essence, backpropagation is a technique to compute multiplications with Jacobians. Methods to extract second-order information (Mizutani & Dreyfus, 2008) or individual gradients from a mini-batch (Goodfellow, 2015) have been known to a small group of specialists; they are just rarely discussed or implemented.
+
+# 1.1 OUR CONTRIBUTION
+
+To address this need for a specialized framework focused on machine learning, we propose a framework for the implementation of generalized backpropagation to compute additional quantities. The structure is based on the conceptual work of Dangel et al. (2019) for modular backpropagation. This framework can be built on top of existing graph-based backpropagation modules; we provide an implementation on top of PYTORCH, coined BACKPACK, available at
+
+https://f-dangel.github.io/backpack/.
+
+The initial release supports efficient computation of individual gradients from a mini-batch, their $\ell _ { 2 }$ norm, an estimate of the variance, as well as diagonal and Kronecker factorizations of the generalized Gauss-Newton (GGN) matrix (see Tab. 1 for a feature overview). The library was designed to be minimally verbose to the user, easy to use (see Fig. 1), and to have low overhead (see $\ S 3$ ). While other researchers are aiming to improve the flexibility of automatic differentiation systems (Innes, 2018a;b; Bradbury et al., 2018), our goal with this package is to provide access to quantities that are only byproducts of the backpropagation pass, rather than gradients themselves.
+
+![](images/180fea69d593c7b1845e2253961a442f3dbae6d655e57354de36b4ca96a10d67.jpg)  
+Figure 1: BACKPACK integrates with PYTORCH to seamlessly extract more information from the backward pass. Instead of the variance (or alongside it, in the same pass), BACKPACK can compute individual gradients in the mini-batch, their $\ell _ { 2 }$ norm and $2 ^ { \mathrm { n d } }$ moment. It can also compute curvature approximations like diagonal or Kronecker factorizations of the GGN such as KFAC, KFLR & KFRA.
+
+To illustrate the capabilities of BACKPACK, we use it to implement preconditioned gradient descent optimizers with diagonal approximations of the GGN and recent Kronecker factorizations KFAC (Martens & Grosse, 2015), KFLR, and KFRA (Botev et al., 2017). Our results show that the curvature approximations based on Monte-Carlo (MC) estimates of the GGN, the approach used by KFAC, give similar progress per iteration to their more accurate counterparts, but being much cheaper to compute. While the na¨ıve update rule we implement does not surpass first-order baselines such as SGD with momentum and Adam (Kingma & Ba, 2015), its implementation with various curvature approximations is made straightforward.
+
+# 2 THEORY AND IMPLEMENTATION
+
+We will distiguish between quantities that can be computed from information already present during a traditional backward pass (which we suggestively call first-order extensions), and quantities that need additional information (termed second-order extensions). The former group contains additional statistics such as the variance of the gradients within the mini-batch or the $\ell _ { 2 }$ norm of the gradient for each sample. Those can be computed with minimal overhead during the backprop pass. The latter class contains approximations of second-order information, like the diagonal or Kronecker factorization of the generalized Gauss-Newton (GGN) matrix, which require the propagation of additional information through the graph. We will present those two classes separately:
+
+# First-order extensions
+
+Extract more from the standard backward pass.
+
+# Second-order extensions
+
+Propagate new information along the graph.
+
+– Individual gradients from a mini-batch $- \ell _ { 2 }$ norm of the individual gradients – Diagonal covariance and $\bar { 2 } ^ { \mathrm { n d } }$ moment – Diagonal of the GGN and the Hessian – KFAC (Martens & Grosse, 2015) – KFRA and KFLR (Botev et al., 2017)
+
+These quantities are only defined, or reasonable to compute, for a subset of models: The concept of individual gradients for each sample in a mini-batch or the estimate of the variance requires the loss for each sample to be independent. While such functions are common in machine learning, not all neural networks fit into this category. For example, if the network uses Batch Normalization (Ioffe & Szegedy, 2015), the individual gradients in a mini-batch are correlated. Then, the variance is not meaningful anymore, and computing the individual contribution of a sample to the mini-batch gradient or the GGN becomes prohibitive. For those reasons, and to limit the scope of the project for version 1.0, BACKPACK currently restricts the type of models it accepts. The supported models are traditional feed-forward networks that can be expressed as a sequence of modules, for example a sequence of convolutional, pooling, linear and activation layers. Recurrent networks like LSTMs (Hochreiter & Schmidhuber, 1997) or residual networks (He et al., 2016) are not yet supported, but the framework can be extended to cover them.
+
+We assume a sequential model $f : \Theta \times \mathbb { X } \to \mathbb { Y }$ and a dataset of $N$ samples $( { \pmb x } _ { n } , { \pmb y } _ { n } ) \in \mathbb { X } \times \mathbb { Y }$ with $n = 1 , \ldots , N$ . The model maps each sample ${ \pmb x } _ { n }$ to a prediction ${ \hat { y } } _ { n }$ using some parameters $\pmb \theta \in \Theta$ . The predictions are evaluated with a loss function $\ell : \mathbf { \bar { Y } } \times \mathbb { Y }  \mathbf { \bar { \mathbb { R } } }$ , for example the cross-entropy, which compares them to the ground truth ${ \bf { { y } } } _ { n }$ . This leads to the objective function $\mathcal { L } : \Theta \to \mathbb { R }$ ,
+
+![](images/8db4f53cd0c079124d1c1a321018be8f3ec4110bfe033c67f0091e225de9df16.jpg)  
+Figure 2: Schematic representation of the standard backpropagation pass for module $i$ with $N$ samples.
+
+$$
+\begin{array} { r } { \mathcal { L } ( \pmb { \theta } ) = \frac { 1 } { N } \sum _ { n = 1 } ^ { N } \ell ( f ( \pmb { \theta } , \pmb { x } _ { n } ) , \pmb { y } _ { n } ) . } \end{array}
+$$
+
+As a shorthand, we will use $\ell _ { n } ( \pmb \theta ) = \ell ( f ( \pmb \theta , \pmb x _ { n } ) , \pmb y _ { n } )$ for the loss and $f _ { n } ( \pmb { \theta } ) = f ( \pmb { \theta } , \pmb { x } _ { n } )$ for the model output of individual samples. Our goal is to provide more information about the derivatives of $\{ \ell _ { n } \} _ { n = 1 } ^ { N }$ with respect to the parameters $\pmb \theta$ of the model $f$ .
+
+# 2.1 PRIMER ON BACKPROPAGATION
+
+Machine learning libraries with integrated automatic differentiation use the modular structure of $f _ { n } ( \pmb \theta )$ to compute derivatives (see Baydin et al. (2018) for an overview). If $f _ { n }$ is a sequence of $L$ transformations, it can be expressed as
+
+$$
+\begin{array} { r } { f _ { n } ( \pmb { \theta } ) = T _ { \pmb { \theta } ^ { ( L ) } } ^ { ( L ) } \circ . . . \circ T _ { \pmb { \theta } ^ { ( 1 ) } } ^ { ( 1 ) } ( \pmb { x } _ { n } ) , } \end{array}
+$$
+
+where T (i)(i) is the ith transformation with parameters $\pmb \theta ^ { ( i ) }$ , such that $\pmb \theta = [ \pmb \theta ^ { ( 1 ) } , \dots , \pmb \theta ^ { ( L ) } ]$ . The loss function can also be seen as another transformation, appended to the network. Let $z _ { n } ^ { ( i - 1 ) } , z _ { n } ^ { ( i ) }$ denote the input and output of the operation $T _ { \pmb { \theta } ^ { ( i ) } } ^ { ( i ) }$ for sample $n$ , such that $z _ { n } ^ { ( 0 ) }$ is the original data and $z _ { n } ^ { ( 1 ) } , \cdots , z _ { n } ^ { ( L ) }$ represent the transformed output of each layer, leading to the computation graph
+
+$$
+z _ { n } ^ { ( 0 ) } \xrightarrow { T _ { \theta ^ { ( 1 ) } } ^ { ( 1 ) } ( z _ { n } ^ { ( 0 ) } ) } z _ { n } ^ { ( 1 ) } \xrightarrow { T _ { \theta ^ { ( 2 ) } } ^ { ( 2 ) } ( z _ { n } ^ { ( 1 ) } ) } . . . \xrightarrow { T _ { \theta ^ { ( L ) } } ^ { ( L ) } ( z _ { n } ^ { ( L - 1 ) } ) } z ^ { ( L ) } \xrightarrow { \ell ( z _ { n } ^ { ( L ) } , y _ { n } ) } \ell _ { n } ( \theta ) .
+$$
+
+To compute the gradient of $\ell _ { n }$ with respect to the $\pmb \theta ^ { ( i ) }$ , one can repeatedly apply the chain rule,
+
+$$
+\begin{array} { r l } & { \nabla _ { \pmb { \theta } ^ { ( i ) } } \ell ( \pmb { \theta } ) = ( \mathrm { J } _ { \pmb { \theta } ^ { ( i ) } } z _ { n } ^ { ( i ) } ) ^ { \top } ( \mathrm { J } _ { z _ { n } ^ { ( i ) } } z _ { n } ^ { ( i + 1 ) } ) ^ { \top } \cdot \cdot \cdot ( \mathrm { J } _ { z _ { n } ^ { ( L - 1 ) } } z _ { n } ^ { ( L ) } ) ^ { \top } ( \nabla _ { z _ { n } ^ { ( L ) } } \ell _ { n } ( \pmb { \theta } ) ) } \\ & { \qquad = ( \mathrm { J } _ { \pmb { \theta } ^ { ( i ) } } z _ { n } ^ { ( i ) } ) ^ { \top } ( \nabla _ { z ^ { ( i ) } } \ell _ { n } ( \pmb { \theta } ) ) , } \end{array}
+$$
+
+where $\mathrm { J } _ { a }  { b }$ is the Jacobian of $^ { b }$ with respect to $^ { a }$ , $[ \mathrm { J } _ { \pmb { a } } \pmb { b } ] _ { i j } = \partial [ \pmb { b } ] _ { i } / \partial [ \pmb { a } ] _ { j }$ . A similar expression exists for the module inputs $z _ { n } ^ { ( i - 1 ) } { \colon } \nabla _ { z _ { n } ^ { ( i - 1 ) } } \ell _ { n } ( \pmb { \theta } ) = ( \mathrm { J } _ { z _ { n } ^ { ( i - 1 ) } } z _ { n } ^ { ( i ) } ) ^ { \top } ( \nabla _ { z _ { n } ^ { ( i ) } } \ell _ { n } ( \pmb { \theta } ) )$ . This recursive structure makes it possible to extract the gradient by propagating the gradient of the loss. In the backpropagation algorithm, a module $i$ receives the loss gradient with respect to its output, $\nabla _ { z _ { n } ^ { ( i ) } } \ell _ { n } ( \pmb { \theta } )$ . It then extracts the gradient with respect to its parameters and inputs, $\nabla _ { \pmb { \theta } ^ { ( i ) } } \ell _ { n } ( \pmb { \theta } )$ and $\nabla _ { z _ { n } ^ { ( i - 1 ) } } \ell _ { n } ( \pmb { \theta } )$ , according to Eq. 3. The gradient with respect to its input is sent further down the graph. This process, illustrated in Fig. 2, is repeated for each transformation until all gradients are computed. To implement backpropagation, each module only needs to know how to multiply with its Jacobians.
+
+For second-order quantities, we rely on the work of Mizutani $\&$ Dreyfus (2008) and Dangel et al. (2019), who showed that a scheme similar to Eq. 3 exists for the block-diagonal of the Hessian. A block with respect to the parameters of a module, $\nabla _ { \pmb { \theta } ^ { ( i ) } } ^ { 2 } \ell _ { n } ( \pmb { \theta } )$ , can be obtained by the recursion
+
+$$
+\begin{array} { r } { \nabla _ { \theta ^ { ( i ) } } ^ { 2 } \ell _ { n } ( \theta ) = ( \mathrm { J } _ { \theta ^ { ( i ) } } z _ { n } ^ { ( i ) } ) ^ { \top } ( \nabla _ { z _ { n } ^ { ( i ) } } ^ { 2 } \ell _ { n } ( \theta ) ) ( \mathrm { J } _ { \theta ^ { ( i ) } } z _ { n } ^ { ( i ) } ) + \sum _ { j } \left( \nabla _ { \theta ^ { ( i ) } } ^ { 2 } [ z _ { n } ^ { ( i ) } ] _ { j } \right) \left[ \nabla _ { z _ { n } ^ { ( i ) } } \ell _ { n } ( \theta ) \right] _ { j } , } \end{array}
+$$
+
+and a similar relation holds for the Hessian with respect to each module’s output, $\nabla _ { z _ { n } ^ { ( i ) } } ^ { 2 } \ell _ { n } ( \pmb { \theta } )$ .
+
+Both backpropagation schemes of Eq. 3 and Eq. 4 hinge on the multiplication by Jacobians to both vectors and matrices. However, the design of automatic differentiation limits the application of Jacobians to vectors only. This prohibits the exploitation of vectorization in the matrix case, which is needed for second-order information. The lacking flexibility of Jacobians is one motivation for our work. Since all quantities needed to compute statistics of the derivatives are already computed during the backward pass, another motivation is to provide access to them at minor overhead.
+
+![](images/4a5956b54ee2c8368128a867974d7ec36a398072d7e59897c49d1e18eedc6b67.jpg)  
+Figure 3: Computing individual gradients in a batch using a for-loop (i.e. one individual forward and backward pass per sample) or using vectorized operations with BACKPACK. The plot shows computation time, comparing to a traditional gradient computation, on the 3C3D network (See $\ S 4 )$ ) for the CIFAR-10 dataset (Schneider et al., 2019).
+
+![](images/665d86e4ed635bce721a4cd30f0da373e8faef46c109492543a40bfb67fcce42.jpg)  
+Figure 4: Schematic representation of the individual gradients’ extraction in addition to the standard backward pass at the ith module for $N$ samples.
+
+# 2.2 FIRST ORDER EXTENSIONS
+
+As the principal first-order extension, consider the computation of the individual gradients in a batch of size $N$ . These individual gradients are implicitly computed during a traditional backward pass because the batch gradient is their sum, but they are not directly accessible. The na¨ıve way to compute $N$ individual gradients is to do $N$ separate forward and backward passes, This (inefficiently) replaces every matrix-matrix multiplications by $N$ matrix-vector multiplications. BACKPACK’s approach batches computations to obtain large efficiency gains, as illustrated by Fig. 3.
+
+As the quantities necessary to compute the individual gradients are already propagated through the computation graph, we can reuse them by inserting code in the standard backward pass. With access to this information, before it is cleared for memory efficiency, BACKPACK computes the Jacobianmultiplications for each sample
+
+$$
+\begin{array} { r } { \{ \nabla _ { \pmb { \theta } ^ { ( i ) } } \ell _ { n } ( \pmb { \theta } ) \} _ { n = 1 } ^ { N } = \{ [ \mathbf { J } _ { \pmb { \theta } ^ { ( i ) } } z _ { n } ^ { ( i ) } ] ^ { \top } \nabla _ { z _ { n } ^ { ( i ) } } \ell _ { n } ( \pmb { \theta } ) \} _ { n = 1 } ^ { N } , } \end{array}
+$$
+
+without summing the result—see Fig. 4 for a schematic representation. This duplicates some of the computation performed by the backpropagation, as the Jacobian is applied twice (once by PYTORCH and BACKPACK with and without summation over the samples, respectively). However, the associated overhead is small compared to the for-loop approach: The major computational cost arises from the propagation of information required for each layer, rather than the formation of the gradient within each layer.
+
+This scheme for individual gradient computation is the basis for all first-order extensions. In this direct form, however, it is expensive in memory: if the model is $D$ -dimensional, storing $\mathcal { O } ( N D )$ elements is prohibitive for large batches. For the variance, $2 ^ { \mathrm { n d } }$ moment and $\ell _ { 2 }$ norm, BACKPACK takes advantage of the Jacobian’s structure to directly compute them without forming the individual gradient, reducing memory overhead. See Appendix A.1 for details.
+
+# 2.3 SECOND-ORDER EXTENSIONS
+
+Second-order extensions require propagation of more information through the graph. As an example, we will focus on the generalized Gauss-Newton (GGN) matrix (Schraudolph, 2002). It is guaranteed to be positive semi-definite and is a reasonable approximation of the Hessian near the minimum, which motivates its use in approximate second-order methods. For popular loss functions, it coincides with the Fisher information matrix used in natural gradient methods (Amari, 1998); for a more in depth discussion of the equivalence, see the reviews of Martens (2014) and Kunstner et al. (2019). For an objective function that can be written as the composition of a loss function $\ell$ and a model $f$ , such as Eq. 1, the GGN of $\begin{array} { r } { { \frac { 1 } { N } } \sum _ { n } \ell ( f ( \pmb { \theta } , \pmb { x } _ { n } ) , \pmb { y } _ { n } ) } \end{array}$ is
+
+$$
+\begin{array} { r } { G ( \pmb { \theta } ) = \frac { 1 } { N } \sum _ { n } \left[ \mathrm { J } _ { \pmb { \theta } } f ( \pmb { \theta } , \pmb { x } _ { n } ) \right] ^ { \top } \nabla _ { f } ^ { 2 } \ell ( f ( \pmb { \theta } , \pmb { x } _ { n } ) , \pmb { y } _ { n } ) \left[ \mathrm { J } _ { \pmb { \theta } } f ( \pmb { \theta } , \pmb { x } _ { n } ) \right] . } \end{array}
+$$
+
+The full matrix is too large to compute and store. Current approaches focus on its diagonal blocks, where each block corresponds to a layer in the network. Every block itself is further approximated, for example using a Kronecker factorization. The approach used by BACKPACK for their computation is a refinement of the Hessian Backpropagation equations of Dangel et al. (2019). It relies on two insights: Firstly, the computational bottleneck in the computation of the GGN is the multiplication with the Jacobian of the network, $\operatorname { J } _ { \theta } f _ { n }$ , while the Hessian of the loss with respect to the output of the network is easy to compute for most popular loss functions. Secondly, it is not necessary to compute and store each of the $N$ $[ D \times D ]$ matrices for a network with $D$ parameters, as Eq. 6 is a quadratic expression. Given a symmetric factorization $S _ { n }$ of the Hessian, $S _ { n } S _ { n } ^ { \top } = \nabla _ { f } ^ { 2 } \hat { \ell } ( f ( \pmb \theta , \pmb x _ { n } ) , \pmb y _ { n } ) .$ , it is sufficient to compute $[ \mathrm { J } _ { \pmb { \theta } } f _ { n } ] ^ { \top } S _ { n }$ and square the result. A network output is typically small compared to its inner layers; networks on CIFAR-100 need $C = 1 0 0$ class outputs but could use convolutional layers with more than 100,000 parameters.
+
+![](images/4d3ebef812aaa743d58fb037d399817c1c7cb134e2edbcf4164ad406033aebd3.jpg)  
+Figure 5: Schematic of the additional backward pass to compute a symmetric factorization of the GGN, $\begin{array} { r } { G ( \pmb { \theta } ) = \sum _ { n } [ \mathrm { J } _ { \pmb { \theta } } f _ { n } ] ^ { \top } \pmb { S } _ { n } \pmb { S } _ { n } ^ { \top } [ \mathrm { J } _ { \pmb { \theta } } f _ { n } ] } \end{array}$ alongside the gradient at the $i$ th module, for $N$ samples.
+
+The factorization leads to a $[ D \times C ]$ matrix, which makes it possible to efficiently compute GGN block diagonals. Also, the computation is very similar to that of a gradient, which computes $[ \mathrm { J } _ { \pmb \theta } f _ { n } ] ^ { \top } \nabla _ { f _ { n } } \ell _ { n }$ . A module multiplies $T _ { \pmb { \theta } ^ { ( i ) } } ^ { ( i ) }$ receives the symmetric factorization of the GGth the Jacobians with respect to the parameters th respect toand inputs tput,  to p $ { \boldsymbol { z } } _ { n } ^ { ( i ) }$ , anduce a $\pmb \theta ^ { ( i ) }$ $z _ { n } ^ { ( i - 1 ) }$ ) rod symmetric factorization of the GGN with respect to the parameters and inputs, as shown in Fig. 5.
+
+This propagation serves as the basis of the second-order extensions. If the full symmetric factorization is not wanted, for memory reasons, it is possible to extract more specific information such as the diagonal. If $\textbf {  { B } }$ is the symmetric factorization for a GGN block, the diagonal can be computed as $\begin{array} { r } { [ { B B ^ { \top } } ] _ { i i } = \sum _ { j } [ B ] _ { i j } ^ { 2 } } \end{array}$ , where $[ \cdot ] _ { i j }$ denotes the element in the ith row and $j$ th column.
+
+This framework can be used to extract the main Kronecker factorizations of the GGN, KFAC and KFLR, which we extend to convolution using the approach of Grosse & Martens (2016). The important difference between the two methods is the initial matrix factorization $S _ { n }$ . Using a full symmetric factorization of the initial Hessian, $S _ { n } S _ { n } ^ { \top } = \nabla _ { f _ { n } } ^ { 2 } \ell _ { n }$ , yields the KFLR approximation. KFAC uses an MC-approximation by sampling a vector $s _ { n }$ such that $\mathbb { E } _ { \pmb { s } _ { n } } [ \pmb { s } _ { n } \pmb { s } _ { n } ^ { \top } ] = \dot { \nabla } _ { f _ { n } } ^ { 2 } \ell _ { n }$ . KFLR is therefore more precise but more expensive than KFAC, especially for networks with high-dimensional outputs, which is reflected in our benchmark on CIFAR-100 in Section 3. The technical details on how Kronecker factors are extracted and information is propagated for second-order BACKPACK extensions are documented in Appendix A.2.
+
+# 3 EVALUATION AND BENCHMARKS
+
+We benchmark the overhead of BACKPACK on the CIFAR-10 and CIFAR-100 datasets, using the 3C3D network3 provided by DEEPOBS (Schneider et al., 2019) and the ALL-CNN- $\mathrm { C } ^ { 4 }$ network of Springenberg et al. (2015). The results are shown in Fig. 6.
+
+For first-order extensions, the computation of individual gradients from a mini-batch adds noticeable overhead due to the additional memory requirements of storing them. But more specific quantities such as the $\ell _ { 2 }$ norm, $2 ^ { \mathrm { n d } }$ moment and variance can be extracted efficiently. Regarding second-order extensions, the computation of the GGN can be expensive for networks with large outputs like CIFAR100, regardless of the approximation being diagonal of Kronecker-factored. Thankfully, the MC approximation used by KFAC, which we also implement for a diagonal approximation, can be computed at minimal overhead—much less than two backward passes. This last point is encouraging, as our optimization experiment in Section 4 suggest that this approximation is reasonably accurate.
+
+![](images/fdbf6d76ad0cc9c2f466958cee9158dbb49cad8ed6c797efd4204810f148f9a2.jpg)  
+Figure 6: Overhead benchmark for computing the gradient and first- or second-order extensions on real networks, compared to just the gradient. Most quantities add little overhead. KFLR and DiagGGN propagate $1 0 0 \times$ more information than KFAC and DiagGGN-MC on CIFAR-100 and are two orders of magnitude slower. We report benchmarks on those, and the Hessian’s diagonal, in Appendix B.
+
+# 4 EXPERIMENTS
+
+To illustrate the utility of BACKPACK, we implement preconditioned gradient descent optimizers using diagonal and Kronecker approximations of the GGN. To our knowledge, and despite their apparent simplicity, results using diagonal approximations or the na¨ıve damping update rule we chose have not been reported in publications so far. However, this section is not meant to introduce a bona-fide new optimizer. Our goal is to show that BACKPACK can enable research of this kind. The update rule we implement uses a curvature matrix $G ( \theta _ { t } ^ { ( i ) } )$ , which could be a diagonal or Kronecker factorization of the GGN blocks, and a damping parameter $\lambda$ to precondition the gradient:
+
+$$
+\pmb { \theta } _ { t + 1 } ^ { ( i ) } = \pmb { \theta } _ { t } ^ { ( i ) } - \alpha ( \pmb { G } ( \pmb { \theta } _ { t } ^ { ( i ) } ) + \lambda \pmb { I } ) ^ { - 1 } \nabla \pmb { \mathcal { L } } ( \pmb { \theta } _ { t } ^ { ( i ) } ) , \qquad i = 1 , \dots , L .
+$$
+
+We run the update rule with the following approximations of the generalized Gauss-Newton: the exact diagonal (DiagGGN) and an MC estimate (DiagGGN-MC), and the Kronecker factorizations KFAC (Martens & Grosse, 2015), KFLR and KFRA5(Botev et al., 2017). The inversion required by the update rule is straightforward for the diagonal curvature. For the Kronecker-factored quantities, we use the approximation introduced by Martens & Grosse (2015) (see Appendix C.3).
+
+These curvature estimates are tested for the training of deep neural networks by running the corresponding optimizers on the main test problems of the benchmarking suite DEEPOBS (Schneider et al., 2019).6 We use the setup (batch size, number of training epochs) of DEEPOBS’ baselines, and tune the learning rate $\alpha$ and damping parameter $\lambda$ with a grid search for each optimizer (details in Appendix C.2). The best hyperparameter settings is chosen according to the final accuracy on a validation set. We report the median and quartiles of the performance for ten random seeds.
+
+Fig. 7a shows the results for the 3C3D network trained on CIFAR-10. The optimizers that leverage Kronecker-factored curvature approximations beat the baseline performance in terms of per-iteration progress on the training loss, training and test accuracy. Using the same hyperparameters, there is little difference between KFAC and KFLR, or DiagGGN and DiagGGN-MC. Given that the quantities based on MC-sampling are considerably cheaper, this experiment suggests it being an important technique for reducing the computational burden of curvature approximations.
+
+Fig. 7b shows benchmarks for the ALL-CNN-C network trained on CIFAR-100. Due to the highdimensional output, the curvatures using a full matrix propagation rather than an MC sample cannot be run on this problem due to memory issues. Both DiagGGN-MC and KFAC can compete with the baselines in terms of progress per iteration. As the update rule we implemented is simplistic on purpose, this is promising for future applications of second-order methods that can more efficiently use the additional information given by curvature approximations.
+
+![](images/dc39639f5f1d4dba9f796e48ef578abf0b665464ba2964cd9ccc95abbef86e36.jpg)  
+Figure 7: Median performance with shaded quartiles of the DEEPOBS benchmark for (a) 3C3D network (895,210 parameters) on CIFAR-10 and (b) ALL-CNN-C network (1,387,108 parameters) on CIFAR-100. Solid lines show baselines of momentum SGD and Adam provided by DEEPOBS.
+
+# 5 CONCLUSION
+
+Machine learning’s coming-of-age has been accompanied, and in part driven, by a maturing of the software ecosystem. This has drastically simplified the lives of developers and researchers alike, but has also crystallized parts of the algorithmic landscape. This has dampened research in cutting-edge areas that are far from mature, like second-order optimization for deep neural networks. To ensure that good ideas can bear fruit, researchers must be able to compute new quantities without an overwhelming software development burden. To support research and development in optimization for deep learning, we have introduced BACKPACK, an efficient implementation in PYTORCH of recent conceptual advances and extensions to backpropagation (Tab. 1 lists all features). BACKPACK enriches the syntax of automatic differentiation packages to offer additional observables to optimizers beyond the batch-averaged gradient. Our experiments demonstrate that BACKPACK’s implementation offers drastic efficiency gains over the kind of na¨ıve implementation within reach of the typical researcher. As a demonstrative example, we “invented” a few optimization routines that, without BACKPACK, would require demanding implementation work and can now be tested with ease. We hope that studies like this allow BACKPACK to help mature the ML software ecosystem further.
+
+# ACKNOWLEDGMENTS
+
+The authors would like to thank Aaron Bahde, Ludwig Bald, and Frank Schneider for their help with DEEPOBS and Lukas Balles, Simon Bartels, Filip de Roos, Tim Fischer, Nicolas Kramer, Agustinus ¨ Kristiadi, Frank Schneider, Jonathan Wenger, and Matthias Werner for constructive feedback.
+
+The authors gratefully acknowledge financial support by the European Research Council through ERC StG Action 757275 / PANAMA; the DFG Cluster of Excellence “Machine Learning - New
+
+Table 1: Overview of the features supported in the first release of BACKPACK.   
+
+<table><tr><td>Feature</td><td>Details</td></tr><tr><td>Individual gradients</td><td>NVθ(ω)ln(0)， n=1,.,N</td></tr><tr><td>Batch variance</td><td>1Vn(0)-(0)</td></tr><tr><td>2nd moment</td><td>N∑n=10oen(0)],，5=1,,a(.</td></tr><tr><td>Indiv. gradient l2 norm</td><td>/∀θ(i)len(θ)ll²， n=1,.,N</td></tr><tr><td>DiagGGN</td><td>diag (G(0(i)))</td></tr><tr><td>DiagGGN-MC</td><td>diag (G(0()）</td></tr><tr><td>Hessian diagonal</td><td>diag (V²() L(θ))</td></tr><tr><td>KFAC</td><td>G(0(i)) ~ A(i) </td></tr><tr><td>KFLR</td><td></td></tr><tr><td>KFRA</td><td>G(0(@)~ A BRA (i)</td></tr></table>
+
+Perspectives for Science”, EXC 2064/1, project number 390727645; the German Federal Ministry of Education and Research (BMBF) through the Tubingen AI Center (FKZ: 01IS18039A); and funds ¨ from the Ministry of Science, Research and Arts of the State of Baden-Wurttemberg. F. D. is grateful ¨ to the International Max Planck Research School for Intelligent Systems (IMPRS-IS) for support.
+
+# REFERENCES
+
+Mart´ın Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, Manjunath Kudlur, Josh Levenberg, Rajat Monga, Sherry Moore, Derek Gordon Murray, Benoit Steiner, Paul A. Tucker, Vijay Vasudevan, Pete Warden, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. Tensorflow: A system for large-scale machine learning. In 12th USENIX Symposium on Operating Systems Design and Implementation, 2016.
+
+Shun-ichi Amari. Natural gradient works efficiently in learning. Neural Computation, 10(2), 1998.
+
+Lukas Balles and Philipp Hennig. Dissecting Adam: The sign, magnitude and variance of stochastic gradients. In Proceedings of the 35th International Conference on Machine Learning, 2018.
+
+Lukas Balles, Javier Romero, and Philipp Hennig. Coupling adaptive batch sizes with learning rates. In Proceedings of the 33rd Conference on Uncertainty in Artificial Intelligence, 2017.
+
+Atilim Gunes Baydin, Barak A. Pearlmutter, Alexey Andreyevich Radul, and Jeffrey Mark Siskind. Automatic differentiation in machine learning: A survey. Journal of Machine Learning Research, 18(153), 2018.
+
+Sue Becker and Yann Le Cun. Improving the convergence of back-propagation learning with second order methods. In Proceedings of the 1988 Connectionist Models Summer School, 1989.
+
+Antoine Bordes, Leon Bottou, and Patrick Gallinari. SGD-QN: careful quasi-Newton stochastic gradient de-´ scent. J. Mach. Learn. Res., 10, 2009.
+
+Aleksandar Botev, Hippolyt Ritter, and David Barber. Practical Gauss-Newton optimisation for deep learning. In Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, 2017.
+
+James Bradbury, Roy Frostig, Peter Hawkins, Matthew James Johnson, Chris Leary, Dougal Maclaurin, and Skye Wanderman-Milne. JAX: Composable transformations of Python+NumPy programs, 2018.
+
+Tianqi Chen, Mu Li, Yutian Li, Min Lin, Naiyan Wang, Minjie Wang, Tianjun Xiao, Bing Xu, Chiyuan Zhang, and Zheng Zhang. MXNet: A flexible and efficient machine learning library for heterogeneous distributed systems. In 31st Conference on Neural Information Processing Systems, Workshop on Machine Learning Systems, 2015.
+
+Felix Dangel, Stefan Harmeling, and Philipp Hennig. A modular approach to block-diagonal Hessian approximations for second-order optimization methods. CoRR, abs/1902.01813, 2019.
+
+Thomas George, Cesar Laurent, Xavier Bouthillier, Nicolas Ballas, and Pascal Vincent. Fast approximate ´ natural gradient descent in a Kronecker-factored eigenbasis. 2018.
+
+Ian J. Goodfellow. Efficient per-example gradient computations. CoRR, abs/1510.01799, 2015.
+
+Roger B. Grosse and James Martens. A Kronecker-factored approximate Fisher matrix for convolution layers. In Proceedings of the 33rd International Conference on Machine Learning, volume 48 of JMLR Workshop and Conference Proceedings, 2016.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In 2016 IEEE Conference on Computer Vision and Pattern Recognition, 2016.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural Computation, 9(8), 1997.
+
+Michael Innes. Flux: Elegant machine learning with Julia. Journal of Open Source Software, 3(25), 2018a.
+
+Michael Innes. Don’t unroll adjoint: Differentiating SSA-form programs. CoRR, abs/1810.07951, 2018b.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In Proceedings of the 32nd International Conference on Machine Learning, volume 37 of JMLR Workshop and Conference Proceedings, 2015.
+
+Angelos Katharopoulos and Franc¸ois Fleuret. Not all samples are created equal: Deep learning with importance sampling. In Proceedings of the 35th International Conference on Machine Learning, 2018.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In 3rd International Conference on Learning Representations, 2015.
+
+Frederik Kunstner, Lukas Balles, and Philipp Hennig. Limitations of the empirical Fisher approximatiom. In Advances in Neural Information Processing Systems 32, 2019.
+
+Nicolas Le Roux, Pierre-Antoine Manzagol, and Yoshua Bengio. Topmoumoute online natural gradient algorithm. In Advances in Neural Information Processing Systems 20, 2007.
+
+Maren Mahsereci and Philipp Hennig. Probabilistic line searches for stochastic optimization. Journal of Machine Learning Research, 18, 2017.
+
+James Martens. New perspectives on the natural gradient method. CoRR, abs/1412.1193, 2014.
+
+James Martens and Roger B. Grosse. Optimizing neural networks with Kronecker-factored approximate curvature. In Proceedings of the 32nd International Conference on Machine Learning, volume 37 of JMLR Workshop and Conference Proceedings, 2015.
+
+James Martens, Jimmy Ba, and Matt Johnson. Kronecker-factored curvature approximations for recurrent neural networks. In 6th International Conference on Learning Representations, 2018.
+
+Eiji Mizutani and Stuart E. Dreyfus. Second-order stagewise backpropagation for Hessian-matrix analyses and investigation of negative curvature. Neural Networks, 21(2-3), 2008.
+
+Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Kopf, Edward Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala. PyTorch: An imperative style, high-performance deep learning library. In Advances in Neural Information Processing Systems 32. 2019.
+
+Frank Schneider, Lukas Balles, and Philipp Hennig. DeepOBS: A deep learning optimizer benchmark suite. In 7th International Conference on Learning Representations, 2019.
+
+Nicol N. Schraudolph. Fast curvature matrix-vector products for second-order gradient descent. Neural Computation, 14(7), 2002.
+
+Jost Tobias Springenberg, Alexey Dosovitskiy, Thomas Brox, and Martin A. Riedmiller. Striving for simplicity: The all convolutional net. In 3rd International Conference on Learning Representations, 2015.
+
+Seiya Tokui, Kenta Oono, Shohei Hido, and Justin Clayton. Chainer: A next-generation open source framework for deep learning. In 29th Conference on Neural Information Processing Systems, Workshop on Machine Learning Systems, 2015.
+
+Yohei Tsuji, Kazuki Osawa, Yuichiro Ueno, Akira Naruse, Rio Yokota, and Satoshi Matsuoka. Performance optimizations and analysis of distributed deep learning with approximated second-order optimization method. In 48th International Conference on Parallel Processing, Workshop Proceedings, 2019.
+
+# BACKPACK: PACKING MORE INTO BACKPROPSUPPLEMENTARY MATERIAL
+
+# Table of Content
+
+– $\ S \mathbf { A }$ : BACKPACK extensions – $\ S \mathrm { A } . 1$ : First-order quantities – $\ S \mathrm { A } . 2$ : Second-order quantities based on the generalized Gauss-Newton – $\ S \mathrm { A } . 3$ : The exact Hessian diagonal   
+$- \ \ S \mathbf { B }$ : Additional details on benchmarks   
+$- ~ \ S C$ : Additional details on experiments   
+$- ~ \mathrm { \  8 D }$ : BACKPACK cheat sheet
+
+# A BACKPACK EXTENSIONS
+
+This section provides more technical details on the additional quantities extracted by BACKPACK.
+
+Notation: Consider an arbitrary module $T _ { \pmb { \theta } ^ { ( i ) } } ^ { ( i ) }$ of a network $i = 1 , \ldots , L$ , parameterized by $\pmb \theta ^ { ( i ) }$ . It transforms the output of its parent layer for sample $n$ , $z _ { n } ^ { ( i - 1 ) }$ , to its output $ { \boldsymbol { z } } _ { n } ^ { ( i ) }$ , i.e.
+
+$$
+z _ { n } ^ { ( i ) } = T _ { \theta ^ { ( i ) } } ^ { ( i ) } ( z _ { n } ^ { ( i - 1 ) } ) , \qquad n = 1 , \dots , N ,
+$$
+
+where $N$ is the number of samples. In particular, $z _ { n } ^ { ( 0 ) } = \pmb { x } _ { n }$ and $z _ { n } ^ { ( L ) } ( \pmb { \theta } ) = f ( \pmb { x } _ { n } , \pmb { \theta } )$ , where $f$ is the transformation of the whole network. The dimension of the hidden layer $i$ ’s output $ { \boldsymbol { z } } _ { n } ^ { ( i ) }$ is written $\it { { h ^ { ( i ) } } }$ and $\pmb \theta ^ { ( i ) }$ is of dimension $\boldsymbol { d } ^ { ( i ) }$ . The dimension of the network output, the prediction $z ^ { ( L ) }$ , is $h ^ { ( L ) } = C$ . For an image classification task, $C$ corresponds to the number of classes.
+
+All quantities are assumed to be vector-shaped. For image-processing transformations that usually act on tensor-shaped inputs, we can reduce to the vector scenario by vectorizing all quantities; this discussion does not rely on a specific flattening scheme. However, for an efficient implementation, vectorization should match the layout of the memory of the underlying arrays.
+
+Jacobian: The Jacobian matrix $\operatorname { J } _ { a } b$ of an arbitrary vector $\pmb { b } \in \mathbb { R } ^ { B }$ with respect to another vector $\mathbf { \pmb { a } } \in \mathbb { R } ^ { A }$ is an $[ A \times B ]$ matrix of partial derivatives, $\left[ \mathrm { J } _ { \pmb { a } } \pmb { b } \right] _ { i j } = \partial \left[ \pmb { b } \right] _ { i } / \partial \left[ \pmb { a } \right] _ { j }$ .
+
+# A.1 FIRST-ORDER QUANTITIES
+
+The basis for the extraction of additional information about first-order derivatives is given by Eq. 3, which we state again for multiple samples,
+
+$$
+\nabla _ { \pmb { \theta } ^ { ( i ) } } \mathscr { L } ( \pmb { \theta } ) = \frac { 1 } { N } \sum _ { n = 1 } ^ { N } \nabla _ { \pmb { \theta } ^ { ( i ) } } \ell _ { n } ( \pmb { \theta } ) = \frac { 1 } { N } \sum _ { n = 1 } ^ { N } ( \mathbf { J } _ { \pmb { \theta } ^ { ( i ) } } z _ { n } ^ { ( i ) } ) ^ { \top } ( \nabla _ { z _ { n } ^ { ( i ) } } \ell _ { n } ( \pmb { \theta } ) ) .
+$$
+
+During the backpropagation step of module $i$ , we have access to $\nabla _ { z _ { n } ^ { ( i ) } } \ell ( \pmb \theta ) , i = 1 , \ldots , N .$ . To extract more quantities involving the gradient, we use additional information about the transformation T (i)θ(i) within our custom implementation of the Jacobian $\mathrm { J } _ { \pmb { \theta } ^ { ( i ) } } \pmb { z } _ { n } ^ { ( i ) }$ and transposed Jacobian $( \mathrm { J } _ { \pmb { \theta } ^ { ( i ) } } z _ { n } ^ { ( i ) } ) ^ { \top }$ .
+
+Individual gradients: The contribution of each sample to the overall gradient, $\frac { 1 } { N } \nabla _ { \pmb { \theta } ^ { ( i ) } } \ell _ { n } ( \pmb { \theta } )$ , is computed by application of the transposed Jacobian,
+
+$$
+\frac { 1 } { N } \nabla _ { \pmb { \theta } ^ { ( i ) } } \ell _ { n } ( \pmb { \theta } ) = \frac { 1 } { N } ( \mathrm { J } _ { \pmb { \theta } ^ { ( i ) } } z _ { n } ^ { ( i ) } ) ^ { \top } ( \nabla _ { z _ { n } ^ { ( i ) } } \ell _ { n } ( \pmb { \theta } ) ) , \qquad n = 1 , \dots , N .
+$$
+
+For each parameter $\pmb \theta ^ { ( i ) }$ the individual gradients are of size $[ N \times d ^ { ( i ) } ]$ .
+
+Individual gradient $\ell _ { 2 }$ norm: The quantity $\begin{array} { r l } { \Big \| \frac { 1 } { N } \nabla _ { \pmb { \theta } ^ { ( i ) } } \ell _ { n } ( \pmb { \theta } ) \Big \| _ { 2 } ^ { 2 } } & { { } } \end{array}$ , for $n = 1 , . . . , N$ , could be extracted from the individual gradients (Eq. 9) as
+
+$$
+\left\| \frac { 1 } { N } \nabla _ { \theta ^ { ( i ) } } \ell _ { n } ( \theta ) \right\| _ { 2 } ^ { 2 } = \left[ \frac { 1 } { N } ( \mathrm { J } _ { \theta ^ { ( i ) } } z _ { n } ^ { ( i ) } ) ^ { \top } ( \nabla _ { z _ { n } ^ { ( i ) } } \ell _ { n } ( \theta ) ) \right] ^ { \top } \left[ \frac { 1 } { N } ( \mathrm { J } _ { \theta ^ { ( i ) } } z _ { n } ^ { ( i ) } ) ^ { \top } ( \nabla _ { z _ { n } ^ { ( i ) } } \ell _ { n } ( \theta ) ) \right] ,
+$$
+
+which is an $N$ -dimensional object for each parameter $\pmb \theta ^ { ( i ) }$ . However, this is not memory efficient as the individual gradients are an $[ N \times d ^ { ( i ) } ]$ tensor. To circumvent this problem, BACKPACK uses the structure of the Jacobian whenever possible.
+
+For a specific example, take a linear layer with parameters $\pmb \theta$ as an $[ A \times B ]$ matrix. The layer transforms the inputs $z _ { n } ^ { ( i - 1 ) }$ , an $[ N \times A ]$ matrix which we will now refer to as $\pmb { A }$ . During the backward pass, it receives the gradient of the individual losses with respect to its output, $\{ \textstyle { \frac { 1 } { N } } \check { \nabla _ { z _ { n } ^ { ( i ) } } } \ell _ { n } \} _ { n = 1 } ^ { N }$ , as an $[ N \times B ]$ matrix which we will refer to as $\textbf {  { B } }$ . The overall gradient, an $[ A \times B ]$ matrix, can be computed as $\mathring { A } ^ { \top } B$ , and the individual gradients are a set of $N$ $[ A \times B ]$ matrices, $\{ \mathbf { \bar { A } } [ n , : ] B [ n , : ] ^ { \top } \} _ { n = 1 } ^ { N }$ . We want to avoid storing that information. To reduce the memory requirement, note that the individual gradient norm can be written as
+
+$$
+\left\| \frac { 1 } { N } \nabla _ { \pmb { \theta } } \ell _ { n } \right\| ^ { 2 } = \sum _ { i } \sum _ { j } ( \pmb { A } [ n , i ] \pmb { B } [ n , j ] ) ^ { 2 } ,
+$$
+
+and that the summation can be done independently for each matrix, as $\begin{array} { r } { \sum _ { i } \sum _ { j } ( { \cal A } [ n , i ] { \cal B } [ n , j ] ) ^ { 2 } = } \end{array}$ $\begin{array} { r l } { ( \sum _ { i } A [ n , i ] ) ^ { 2 } ( \sum _ { j } B [ n , j ] ^ { 2 } ) } & { { } } \end{array}$ . Therefore, we can square each matrix (element-wise) and sum over non-batch dimensions. This yields vectors $\mathbf { \delta } _ { a , b }$ of $N$ elements, where $\begin{array} { r } { { \bf { a } } [ n ] = \sum _ { i } { \bf { A } } [ n , i ] ^ { 2 } } \end{array}$ . The individual gradients’ $\ell _ { 2 }$ norm is then given by $\mathbf { \Pi } _  \mathbf { \Omega } \mathbf { \Omega } \mathbf { \Omega } \mathbf { \Omega } \mathbf { \Omega } \mathbf { \Omega } \mathbf { \Omega } \mathbf { \Omega } \mathbf { \Omega } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf { \Sigma } \mathbf \Sigma { \Sigma } \mathbf \mathbf { \Sigma } \mathbf { \Sigma \Sigma } \mathbf \mathbf { \Sigma } \mathbf { \Sigma \Sigma } \mathbf \mathbf { \Sigma \Sigma } \mathbf \Sigma \mathbf { \Sigma } \mathbf \Sigma \Sigma \Sigma \mathbf { \Sigma \Sigma } \mathbf \Sigma \mathbf \Sigma \Sigma \Sigma \mathbf \Sigma \Sigma \Sigma \Sigma \mathbf \Sigma \Sigma \Sigma \mathbf \Sigma \Sigma \Sigma \mathbf \Sigma \Sigma \Sigma \mathbf \Sigma \Sigma \Sigma \Sigma \mathbf \Sigma \Sigma \Sigma \Sigma \mathbf \Sigma \Sigma \Sigma \Sigma \Sigma \mathbf \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \mathbf \Sigma \Sigma \Sigma \Sigma \mathbf \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \mathbf \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \mathbf \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma \Sigma$ where $\circ$ is element-wise multiplication.
+
+Second moment: The gradient second moment (or more specifically, the diagonal of the second moment) is the sum of the squared elements of the individual gradients in a mini-batch, i.e.
+
+$$
+\frac { 1 } { N } \sum _ { n = 1 } ^ { N } \left[ \nabla _ { \pmb { \theta } ^ { ( i ) } } \ell _ { n } ( \pmb { \theta } ) \right] _ { j } ^ { 2 } , \qquad j = 1 , \ldots , d ^ { ( i ) } .
+$$
+
+It can be used to evaluate the variance of individual elements of the gradient (see below). The second moment is of dimension $\boldsymbol { d } ^ { ( i ) }$ , the same dimension as the layer parameter $\pmb \theta ^ { ( i ) }$ . Similarly to the $\ell _ { 2 }$ norm, it can be computed from individual gradients, but is more efficiently computed implicitly.
+
+Revisiting the example of the linear layer from the individual $\ell _ { 2 }$ norm computation, the second moment of the parameters $\theta [ i , j ]$ is given by $\textstyle \sum _ { n } ( A [ n , i ] B [ n , j ] ) ^ { 2 }$ , which can be directly computed by taking the element-wise square of $\pmb { A }$ and $\textbf {  { B } }$ element-wise, $A ^ { 2 } , B ^ { 2 }$ , and computing $A ^ { 2 \top } B ^ { 2 }$ .
+
+Variance: Gradient variances over a mini-batch (or more precisely, the diagonal of the covariance) can be computed using the second moment and the gradient itself,
+
+$$
+\frac { 1 } { N } \sum _ { n = 1 } ^ { N } \left[ \nabla _ { \pmb { \theta } ^ { ( i ) } } \ell _ { n } ( \pmb { \theta } ) \right] _ { j } ^ { 2 } - \left[ \nabla _ { \pmb { \theta } ^ { ( i ) } } \mathcal { L } ( \pmb { \theta } ) \right] _ { j } ^ { 2 } , \qquad j = 1 , \dots , d ^ { ( i ) } .
+$$
+
+The element-wise gradient variance of same dimension as the layer parameter $\pmb \theta ^ { ( i ) }$ , i.e. $\boldsymbol d ^ { ( i ) }$ .
+
+# A.2 SECOND-ORDER QUANTITIES BASED ON THE GENERALIZED GAUSS-NEWTON
+
+The computation of quantities that originate from the approximations of the Hessian require an additional backward pass (see Dangel et al. (2019)). Most curvature approximations supported by BACKPACK rely on the generalized Gauss-Newton (GGN) matrix (Schraudolph, 2002)
+
+$$
+\boldsymbol { G } ( \boldsymbol { \theta } ) = \frac { 1 } { N } \sum _ { n = 1 } ^ { N } ( \mathrm { J } _ { \boldsymbol { \theta } } f ( \mathbf { x } _ { n } , \boldsymbol { \theta } ) ) ^ { \top } \nabla _ { f } ^ { 2 } \ell ( f ( \mathbf { x } _ { n } , \boldsymbol { \theta } ) , y _ { n } ) ( \mathrm { J } _ { \boldsymbol { \theta } } f ( \mathbf { x } _ { n } , \boldsymbol { \theta } ) ) .
+$$
+
+One interpretation of the GGN is that it corresponds to the empirical risk Hessian when the model $f$ is approximated with its first-order Taylor expansion, i.e. by linearizing the network and ignoring
+
+second-order effects. Hence, the effect of module curvature in the recursive scheme of Eq. 4 can be ignored to obtain the simpler expression
+
+$$
+\begin{array} { l } { { \displaystyle { \cal G } ( \pmb { \theta } ^ { ( i ) } ) = \frac { 1 } { N } \sum _ { n = 1 } ^ { N } ( \mathrm { J } _ { \pmb { \theta } ^ { ( i ) } } { f } ) ^ { \top } \nabla _ { f } ^ { 2 } \ell ( f ( \pmb { x } _ { n } , \pmb { \theta } ) , \pmb { y } _ { n } ) ( \mathrm { J } _ { \pmb { \theta } ^ { ( i ) } } { f } ) } \ ~ } \\ { { \displaystyle ~ = \frac { 1 } { N } \sum _ { n = 1 } ^ { N } ( \mathrm { J } _ { \pmb { \theta } ^ { ( i ) } } z _ { n } ^ { ( i ) } ) ^ { \top } { \pmb { G } } ( z _ { n } ^ { ( i ) } ) ( \mathrm { J } _ { \pmb { \theta } ^ { ( i ) } } z _ { n } ^ { ( i ) } ) } } \end{array}
+$$
+
+for the exact block diagonal of the full GGN. In analogy to $G ( \pmb \theta ^ { ( i ) } )$ we have introduced the $[ d ^ { ( i ) } \times$ $d ^ { ( i ) } ]$ -dimensional quantity
+
+$$
+\begin{array} { r } { \pmb { G } ( z _ { n } ^ { ( i ) } ) = ( \mathrm { J } _ { z _ { n } ^ { ( i ) } } f ) ^ { \top } \nabla _ { f } ^ { 2 } \ell ( f ( \pmb { x } _ { n } , \pmb { \theta } ) , \pmb { y } _ { n } ) ( \mathrm { J } _ { z _ { n } ^ { ( i ) } } f ) } \end{array}
+$$
+
+that needs to be backpropagated. The curvature backpropagation also follows from Eq. 4 as
+
+$$
+\begin{array} { r } { G ( z _ { n } ^ { ( i - 1 ) } ) = ( \mathrm { J } _ { z _ { n } ^ { ( i - 1 ) } } z _ { n } ^ { ( i ) } ) ^ { \top } G ( z _ { n } ^ { ( i ) } ) ( \mathrm { J } _ { z _ { n } ^ { ( i - 1 ) } } z _ { n } ^ { ( i ) } ) , \qquad i = 1 , \dots , L , } \end{array}
+$$
+
+and is initialized with the Hessian of the loss function with respect to the network prediction, i.e.
+
+$$
+\begin{array} { r } { \pmb { G } ( \pmb { z } _ { n } ^ { ( L ) } ) = \nabla _ { f } ^ { 2 } \ell ( f ( \pmb { x } _ { n } , \pmb { \theta } ) , \pmb { y } _ { n } ) . } \end{array}
+$$
+
+Although this scheme is exact, it is computationally infeasible as it requires the backpropagation of $N \ [ h ^ { ( i ) } \times h ^ { ( i ) } ]$ matrices between module $i + 1$ and $i$ . Even for small $N$ , this is not possible for networks containing large convolutions.
+
+As an example, the first layer of the ALL-CNN-C network outputs $2 9 \times 2 9$ images with 96 channels, which already gives $h ^ { ( i ) } \stackrel { \cdot } { = } 8 0 \sqrt { 3 6 }$ , which leads to half a Gigabyte per sample. Moreover, storing all the $[ d ^ { ( i ) } \times d ^ { ( i ) } ]$ -dimensional blocks $G ( \pmb \theta ^ { ( i ) } )$ is not possible. BACKPACK implements different approximation strategies, developed by Martens & Grosse (2015) and Botev et al. (2017) that address both of these complexity issues from different perspectives.
+
+Symmetric factorization scheme: One way to improve the memory footprint of the backpropagated matrices in the case where the model prediction’s dimension $C$ (the number of classes in an image classification task) is small compared to all hidden features $\it { h ^ { ( i ) } }$ is to propagate a symmetric factorization of the GGN instead. It relies on the observation that if the loss function itself is convex, even though its composition with the network might not be, its Hessian with respect to the network output can be decomposed as
+
+$$
+\nabla _ { f } ^ { 2 } \ell ( f ( \pmb { x } _ { n } , \pmb { \theta } ) , \pmb { y } _ { n } ) = \pmb { S } ( \pmb { z } _ { n } ^ { ( L ) } ) \pmb { S } ( \pmb { z } _ { n } ^ { ( L ) } ) ^ { \top }
+$$
+
+with the $\left[ C \times C \right]$ -dimensional matrix factorization of the loss Hessian, ${ \cal S } ( z _ { n } ^ { ( L ) } )$ , for sample $n$ . Consequently, the GGN in Eq. 12 reduces to an outer product,
+
+$$
+G ( \pmb \theta ) = \frac { 1 } { N } \sum _ { n = 1 } ^ { N } \left[ ( \mathrm { J } _ { \pmb \theta } f ) ^ { \top } \pmb S ( z _ { n } ^ { ( L ) } ) \right] \left[ ( \mathrm { J } _ { \pmb \theta } f ) ^ { \top } \pmb S ( z _ { n } ^ { ( L ) } ) \right] ^ { \top } .
+$$
+
+The analogue for diagonal blocks follows from Eq. 13 and reads
+
+$$
+\pmb { G } ( \pmb { \theta } ^ { ( i ) } ) = \frac { 1 } { N } \sum _ { n = 1 } ^ { N } \left[ ( \mathbf { J } _ { \pmb { \theta } ^ { ( i ) } } \pmb { z } _ { n } ^ { ( i ) } ) ^ { \top } \pmb { S } ( \pmb { z } _ { n } ^ { ( i ) } ) \right] \left[ ( \mathbf { J } _ { \pmb { \theta } ^ { ( i ) } } \pmb { z } _ { n } ^ { ( i ) } ) ^ { \top } \pmb { S } ( \pmb { z } _ { n } ^ { ( i ) } ) \right] ^ { \top } ,
+$$
+
+where we defined the $[ h ^ { ( i ) } \times C ]$ -dimensional matrix square root $S ( z _ { n } ^ { ( i ) } ) = ( \mathrm { J } _ { z _ { n } ^ { ( i ) } } f ) ^ { \top } S ( z _ { n } ^ { ( L ) } )$ . Instead of having layer $i$ backpropagate $N$ objects of shape $[ h ^ { ( i ) } \times h ^ { ( i ) } ]$ according to Eq. 14, we instead backpropagate the matrix square root via
+
+$$
+\begin{array} { r } { S ( z _ { n } ^ { ( i - 1 ) } ) = ( \mathrm { J } _ { z _ { n } ^ { ( i - 1 ) } } z _ { n } ^ { ( i ) } ) ^ { \top } S ( z _ { n } ^ { ( i ) } ) ( \mathrm { J } _ { z _ { n } ^ { ( i - 1 ) } } z _ { n } ^ { ( i ) } ) , \qquad i = 1 , \dots , L , } \end{array}
+$$
+
+starting with Eq. 15. This reduces the backpropagated matrix of layer $i$ to $[ h ^ { ( i ) } \times C ]$ for each sample.
+
+# A.2.1 DIAGONAL CURVATURE APPROXIMATIONS
+
+Diagonal of the GGN (DiagGGN): The factorization trick for the loss Hessian reduces the size of the backpropagated quantities, but does not address the intractable size of the GGN diagonal blocks $G ( \pmb \theta ^ { \bar { ( } i ) } )$ . In BACKPACK, we can extract diag $\left( G ( \pmb \theta ^ { ( i ) } ) \right)$ given the backpropagated quantities ${ \cal S } ( z _ { n } ^ { ( i ) } ) , i = 1 , . . . , N$ , without building up the matrix representation of Eq. 17. In particular, we compute
+
+$$
+\mathrm { d i a g } \left( G ( \pmb { \theta } ^ { ( i ) } ) \right) = \frac { 1 } { N } \sum _ { n = 1 } ^ { N } \mathrm { d i a g } \left( \left[ \big ( \mathbf { J } _ { \pmb { \theta } ^ { ( i ) } } z _ { n } ^ { ( i ) } \big ) ^ { \top } S ( z _ { n } ^ { ( i ) } ) \right] \left[ \big ( \mathbf { J } _ { \pmb { \theta } ^ { ( i ) } } z _ { n } ^ { ( i ) } \big ) ^ { \top } S ( z _ { n } ^ { ( i ) } ) \right] ^ { \top } \right) .
+$$
+
+Diagonal of the GGN with MC sampled loss Hessian (DiagGGN-MC): We use the same backpropagation strategy of Eq. 18, replacing the symmetric factorization of Eq. 15 with an approximation by a smaller matrix $\tilde { \pmb { S } } ( z _ { n } ^ { ( L ) } )$ of size $[ C \times \tilde { C } ]$ and $\tilde { C } < C$ ,
+
+$$
+\begin{array} { r } { \nabla _ { f } ^ { 2 } \ell ( f ( { \pmb x } _ { n } , \pmb \theta ) , { \pmb y } _ { n } ) \approx \tilde { \pmb S } ( { \pmb z } _ { n } ^ { ( L ) } ) \left( \tilde { \pmb S } ( { \pmb z } _ { n } ^ { ( L ) } ) \right) ^ { \top } . } \end{array}
+$$
+
+This further reduces the size of backpropagated curvature quantities. Martens $\&$ Grosse (2015) introduced such a sampling scheme with KFAC based on the connection between the GGN and the Fisher. Most loss functions used in machine learning have a probabilistic interpretation as negative log-likelihood of a probabilistic model. The squarred error of regression is equivalent to a Gaussian noise assumption and the cross-entropy is linked to the categorical distribution. In this case, the loss Hessian with respect to the network output is equal, in expectation, to the outer products of gradients if the output of the network is sampled according to a particular distribution, $p _ { f } ( { \pmb x } )$ , defined by the network output $f ( { \pmb x } )$ . Sampling outputs $\hat { y } \sim p$ , we have that
+
+$$
+\begin{array} { r } { \mathbb { E } _ { \hat { y } \sim p _ { f ( \mathbf { x } ) } } \left[ \nabla _ { \theta } \ell ( f ( \boldsymbol { x } , \theta ) , \hat { y } ) \nabla _ { \theta } \ell ( f ( \boldsymbol { x } , \theta ) , \hat { y } ) ^ { \top } \right] = \nabla _ { \theta } ^ { 2 } \ell ( f ( \boldsymbol { x } , \theta ) , y ) . } \end{array}
+$$
+
+Sampling one such gradient leads to a rank-1 MC approximation of the loss Hessian. With the substitution $S  \tilde { S }$ , we compute an MC approximation of the GGN diagonal in BACKPACK as
+
+$$
+\mathrm { d i a g } \left( G ( \pmb { \theta } ^ { ( i ) } ) \right) \approx \frac { 1 } { N } \sum _ { n = 1 } ^ { N } \mathrm { d i a g } \left( \left[ \left( \mathbf { J } _ { \pmb { \theta } ^ { ( i ) } } z _ { n } ^ { ( i ) } \right) ^ { \top } \tilde { \pmb { S } } ( z _ { n } ^ { ( i ) } ) \right] \left[ \left( \mathbf { J } _ { \pmb { \theta } ^ { ( i ) } } z _ { n } ^ { ( i ) } \right) ^ { \top } \tilde { \pmb { S } } ( z _ { n } ^ { ( i ) } ) \right] ^ { \top } \right) .
+$$
+
+# A.2.2 KRONECKER-FACTORED CURVATURE APPROXIMATIONS
+
+A different approach to reduce memory complexity of the GGN blocks $G ( \pmb \theta ^ { ( i ) } )$ , apart from diagonal curvature approximations, is representing them as Kronecker products (KFAC for linear and convolution layers by Martens $\&$ Grosse (2015); Grosse $\&$ Martens (2016) KFLR and KFRA for linear layers by Botev et al. (2017)),
+
+$$
+\begin{array} { r } { G ( \pmb \theta ^ { ( i ) } ) = \pmb A ^ { ( i ) } \otimes \pmb B ^ { ( i ) } . } \end{array}
+$$
+
+For both linear and convolution layers, the first Kronecker factor $\boldsymbol { A } ^ { ( i ) }$ is obtained from the inputs $z _ { n } ^ { ( i - 1 ) }$ to layer $i$ . Instead of repeating the technical details of the aforementioned references, we will focus on how they differ in (i) the backpropagated quantities and (ii) the backpropagation strategy. As a result, we will be able to extend KFLR and KFRA to convolutional neural networks7.
+
+KFAC and KFLR: KFAC uses an MC-sampled estimate of the loss Hessian with a square root factorization $\tilde { \cal S } ( z _ { n } ^ { ( L ) } )$ like in Eq. 20. The backpropagation is equivalent to the computation of the GGN diagonal. For the GGN of the weights of a linear layer $i$ , the second Kronecker term is given by
+
+$$
+\boldsymbol { B } _ { \mathrm { K F A C } } ^ { ( i ) } = \frac { 1 } { N } \sum _ { n = 1 } ^ { N } \tilde { \boldsymbol { S } } ( \boldsymbol { z } _ { n } ^ { ( i ) } ) \left( \tilde { \boldsymbol { S } } ( \boldsymbol { z } _ { n } ^ { ( i ) } ) \right) ^ { \top } ,
+$$
+
+which at the same time corresponds to the GGN of the layer’s bias8.
+
+In contrast to KFAC, the KFLR approximation backpropagates the exact square root factorization $S ( z _ { n } ^ { ( L ) } )$ , i.e. for the weights of a linear layer8 (see Botev et al. (2017) for more details)
+
+$$
+B _ { \mathrm { K F L R } } ^ { ( i ) } = \frac { 1 } { N } \sum _ { n = 1 } ^ { N } S ( z _ { n } ^ { ( i ) } ) \left( S ( z _ { n } ^ { ( i ) } ) \right) ^ { \top } .
+$$
+
+KFRA: The backpropagation strategy for KFRA eliminates the scaling of the backpropagated curvature quantities with the batch size $N$ in Eq. 14. Instead of having layer $i$ receive the $N$ exact $[ h ^ { ( i ) } \times h ^ { ( i ) } ]$ matrices $G ( z _ { n } ^ { ( i ) } )$ , $n = 1 , \ldots , N$ , only a single averaged object, denoted $\overline { { \boldsymbol { G } } } ^ { ( i ) }$ , is used as an approximation. In particular, the recursion changes to
+
+$$
+\overline { { G } } ^ { ( i - 1 ) } = \frac { 1 } { N } \sum _ { n = 1 } ^ { N } ( \mathrm { J } _ { z _ { n } ^ { ( i - 1 ) } } z _ { n } ^ { ( i ) } ) ^ { \top } \overline { { G } } ^ { ( i ) } ( \mathrm { J } _ { z _ { n } ^ { ( i - 1 ) } } z _ { n } ^ { ( i ) } ) , \qquad i = 1 , \dots , L ,
+$$
+
+and is initialized with the batch-averaged loss Hessian
+
+$$
+\overline { { \pmb { G } } } ^ { ( L ) } = \frac { 1 } { N } \sum _ { n = 1 } ^ { N } \nabla _ { f } ^ { 2 } \ell ( f ( \pmb { x } _ { n } , \pmb { \theta } ) , \pmb { y } _ { n } ) .
+$$
+
+For a linear layer, KFRA uses8 (see Botev et al. (2017) for more details)
+
+$$
+B _ { \mathrm { K F R A } } ^ { ( i ) } = \overline { { \mathbf { G } } } ^ { ( i ) } .
+$$
+
+# A.3 THE EXACT HESSIAN DIAGONAL
+
+For neural networks consisting only of piecewise linear activation functions, computing the diagonal of the Hessian is equivalent to computing the GGN diagonal. This is because for these activations the second term in the Hessian backpropagation recursion (Eq. 4) vanishes.
+
+However, for activation functions with non-vanishing second derivative, these residual terms have to be accounted for in the backpropagation. The Hessian backpropagation for module $i$ reads
+
+$$
+\begin{array} { r l } & { \quad \nabla _ { \pmb { \theta } ^ { ( i ) } } ^ { 2 } \ell ( \pmb { \theta } ) = ( \mathrm { J } _ { \pmb { \theta } ^ { ( i ) } } z _ { n } ^ { ( i ) } ) ^ { \top } ( \nabla _ { z _ { n } ^ { ( i ) } } ^ { 2 } \ell ( \pmb { \theta } ) ) ( \mathrm { J } _ { \pmb { \theta } ^ { ( i ) } } z _ { n } ^ { ( i ) } ) + \pmb { R } _ { n } ^ { ( i ) } ( \pmb { \theta } ^ { ( i ) } ) , } \\ & { \nabla _ { z _ { n } ^ { ( i - 1 ) } } ^ { 2 } \ell ( \pmb { \theta } ) = ( \mathrm { J } _ { z _ { n } ^ { ( i - 1 ) } } z _ { n } ^ { ( i ) } ) ^ { \top } ( \nabla _ { z _ { n } ^ { ( i ) } } ^ { 2 } \ell ( \pmb { \theta } ) ) ( \mathrm { J } _ { z _ { n } ^ { ( i - 1 ) } } z _ { n } ^ { ( i ) } ) + \pmb { R } _ { n } ^ { ( i ) } ( z _ { n } ^ { ( i - 1 ) } ) , } \end{array}
+$$
+
+for $n = 1 , \ldots , N$ . Those $[ h ^ { ( i ) } \times h ^ { ( i ) } ]$ -dimensional residual terms are defined as
+
+$$
+\begin{array} { r l r } & { } & { \pmb { R } _ { n } ^ { ( i ) } ( \pmb { \theta } ^ { ( i ) } ) = \displaystyle \sum _ { j } \left( \nabla _ { \pmb { \theta } ^ { ( i ) } } ^ { 2 } [ z _ { n } ^ { ( i ) } ] _ { j } \right) \left[ \nabla _ { z _ { n } ^ { ( i ) } } \ell ( \pmb { \theta } ) \right] _ { j } , } \\ & { } & { \pmb { R } _ { n } ^ { ( i ) } ( z _ { n } ^ { ( i - 1 ) } ) = \displaystyle \sum _ { j } \left( \nabla _ { z _ { n } ^ { ( i - 1 ) } } ^ { 2 } [ z _ { n } ^ { ( i ) } ] _ { j } \right) \left[ \nabla _ { z _ { n } ^ { ( i ) } } \ell ( \pmb { \theta } ) \right] _ { j } , } \end{array}
+$$
+
+For common parameterized layers, such as linear and convolution transformations, ${ \pmb R } _ { n } ^ { ( i ) } ( { \pmb \theta } ^ { ( i ) } ) = 0$ If the activation function is applied element-wise, $\pmb { R } _ { n } ^ { ( i ) } ( \pmb { z } _ { n } ^ { ( i - 1 ) } )$ are diagonal matrices.
+
+Storing these quantities becomes very memory-intensive for high-dimensional nonlinear activation layers. In BACKPACK, this complexity is reduced by application of the aforementioned matrix square root factorization trick. To do so, we express the symmetric factorization of $\pmb { R } _ { n } ^ { ( i ) } ( z _ { n } ^ { ( i - 1 ) } )$ as
+
+$$
+\begin{array} { r } { \pmb { R } _ { n } ^ { ( i ) } ( z _ { n } ^ { ( i - 1 ) } ) = \pmb { P } _ { n } ^ { ( i ) } ( z _ { n } ^ { ( i - 1 ) } ) \left( \pmb { P } _ { n } ^ { ( i ) } ( z _ { n } ^ { ( i - 1 ) } ) \right) ^ { \top } - \pmb { N } _ { n } ^ { ( i ) } ( z _ { n } ^ { ( i - 1 ) } ) \left( \pmb { N } _ { n } ^ { ( i ) } ( z _ { n } ^ { ( i - 1 ) } ) \right) ^ { \top } , } \end{array}
+$$
+
+where $P _ { n } ^ { ( i ) } ( z _ { n } ^ { ( i - 1 ) } ) , N _ { n } ^ { ( i ) } ( z _ { n } ^ { ( i - 1 ) } )$ represent the matrix square root of $\pmb { R } _ { n } ^ { ( i ) } ( z _ { n } ^ { ( i - 1 ) } )$ projected on its positive and negative eigenspace, respectively.
+
+This composition allows for the extension of the GGN backpropagation: In addition to $S ( z _ { n } ^ { ( i ) } )$ , the decompositions $P _ { n } ^ { ( i ) } ( z _ { n } ^ { ( i - 1 ) } ) , N _ { n } ^ { ( i ) } ( z _ { n } ^ { ( i - 1 ) } )$ (z(i−1)n ) for the residual parts also have to be backpropagated according to Eq. 18. All diagonals are extracted from the backpropagated matrix square roots (see Eq. 19). All diagonals stemming from decompositions in the negative residual eigenspace have to be weighted by a factor of $- 1$ before summation.
+
+In terms of complexity, one backpropagation for $R _ { n } ^ { ( i ) } ( z ^ { ( i - 1 ) } )$ changes the dimensionality as follows
+
+$$
+{ \cal R } _ { n } ^ { ( i ) } ( z ^ { ( i - 1 ) } ) : \quad \quad [ { h } ^ { ( i ) } \times { h } ^ { ( i ) } ]  [ { h } ^ { ( i - 1 ) } \times { h } ^ { ( i - 1 ) } ]  [ { h } ^ { ( i - 2 ) } \times { h } ^ { ( i - 2 ) } ]  . . . .
+$$
+
+With the square root factorization, one instead obtains
+
+$$
+\begin{array} { r l } { P _ { n } ^ { ( i ) } ( z _ { n } ^ { ( i - 1 ) } ) : } & { \quad [ h ^ { ( i ) } \times h ^ { ( i ) } ] \to [ h ^ { ( i - 1 ) } \times h ^ { ( i ) } ] \to [ h ^ { ( i - 2 ) } \times h ^ { ( i ) } ] \to \dots , } \\ { N _ { n } ^ { ( i ) } ( z _ { n } ^ { ( i - 1 ) } ) : } & { \quad [ h ^ { ( i ) } \times h ^ { ( i ) } ] \to [ h ^ { ( i - 1 ) } \times h ^ { ( i ) } ] \to [ h ^ { ( i - 2 ) } \times h ^ { ( i ) } ] \to \dots . } \end{array}
+$$
+
+Roughly speaking, this scheme is more efficient whenever the hidden dimension of a nonlinear activation layer deceeds the largest hidden dimension of the network.
+
+Example: Consider one backpropagation step of module $i$ . Assume $R _ { n } ^ { ( i ) } ( { \pmb \theta } ^ { ( i ) } ) = 0$ , i.e. a linear, convolution, or non-parameterized layer. Then the following computations are performed in the protocol for the diagonal Hessian:
+
+• Receive the following quantities from the child module $i + 1$ (for $n = 1 , \ldots , N )$
+
+$$
+\begin{array} { r l } & { \Phi = \Big \{ S ( z _ { n } ^ { ( i ) } ) , } \\ & { \qquad P _ { n } ^ { ( i + 1 ) } ( z _ { n } ^ { ( i ) } ) , } \\ & { \qquad N _ { n } ^ { ( i + 1 ) } ( z _ { n } ^ { ( i ) } ) , } \\ & { \qquad ( \boldsymbol { \mathrm { J } } _ { z _ { n } ^ { ( i ) } } z _ { n } ^ { ( i + 1 ) } ) ^ { \top } P _ { n } ^ { ( i + 2 ) } ( z _ { n } ^ { ( i + 1 ) } ) , } \\ & { \qquad ( \boldsymbol { \mathrm { J } } _ { z _ { n } ^ { ( i ) } } z _ { n } ^ { ( i + 1 ) } ) ^ { \top } N _ { n } ^ { ( i + 2 ) } ( z _ { n } ^ { ( i + 1 ) } ) , } \\ & { \qquad \cdots } \\ & { \qquad ( \boldsymbol { \mathrm { J } } _ { z ^ { ( i ) } } z _ { n } ^ { ( i + 1 ) } ) ^ { \top } ( \boldsymbol { \mathrm { J } } _ { z ^ { ( i + 1 ) } } z _ { n } ^ { ( i + 2 ) } ) ^ { \top } \cdots \cdot ( \boldsymbol { \mathrm { J } } _ { z _ { n } ^ { ( i - 3 ) } } z _ { n } ^ { ( i - 2 ) } ) ^ { \top } P _ { n } ^ { ( i - 1 ) } ( z _ { n } ^ { ( i - 2 ) } ) , } \\ & { \qquad ( \boldsymbol { \mathrm { J } } _ { z _ { n } ^ { ( i ) } } z _ { n } ^ { ( i + 1 ) } ) ^ { \top } ( \boldsymbol { \mathrm { J } } _ { z _ { n } ^ { ( i + 1 ) } } z _ { n } ^ { ( i + 2 ) } ) ^ { \top } \cdots \cdot ( \boldsymbol { \mathrm { J } } _ { z _ { n } ^ { ( i - 3 ) } } z _ { n } ^ { ( i - 2 ) } ) ^ { \top } N _ { n } ^ { ( i - 1 ) } ( z _ { n } ^ { ( i - 2 ) } ) \Big \} } \end{array}
+$$
+
+• Extract the module parameter Hessian diagonal, $\mathrm { d i a g } \left( \nabla _ { \pmb { \theta } ^ { ( i ) } } ^ { 2 } \mathcal { L } ( \pmb { \theta } ) \right)$
+
+– For each quantity $A \in \Phi$ extract the diagonal from the square root factorization and sum over the samples, i.e. compute
+
+$$
+\frac { 1 } { N } \sum _ { n = 1 } ^ { N } \mathrm { d i a g } \left( \left[ \big ( \mathbf { J } _ { \pmb { \theta } ^ { ( i ) } } \pmb { z } _ { n } ^ { ( i ) } \big ) ^ { \top } \pmb { A } _ { n } \right] \left[ \big ( \mathbf { J } _ { \pmb { \theta } ^ { ( i ) } } \pmb { z } _ { n } ^ { ( i ) } \big ) ^ { \top } \pmb { A } _ { n } \right] ^ { \top } \right) .
+$$
+
+Multiply the expression by $- 1$ if $\pmb { A }$ stems from backpropagation of a residual’s negative eigenspace’s factorization.
+
+– Sum all expressions to obtain the block Hessian’s diagonal diag $\left( \nabla _ { \pmb { \theta } ^ { ( i ) } } ^ { 2 } \mathcal { L } ( \pmb { \theta } ) \right)$
+
+• Backpropagate the received quantities to the parent module $i - 1$ – For each quantity $A _ { n } \in \Phi$ , apply $( \mathrm { J } _ { \pmb { z } _ { n } ^ { ( i - 1 ) } } \pmb { z } _ { n } ^ { ( i ) } ) ^ { \top } \pmb { A } _ { n }$ – Append $P _ { n } ^ { ( i + 1 ) } ( z _ { n } ^ { ( i ) } )$ and $N _ { n } ^ { ( i + 1 ) } ( z _ { n } ^ { ( i ) } )$ to $\Phi$
+
+# B ADDITIONAL DETAILS ON BENCHMARKS
+
+KFAC vs. KFLR: As the KFLR of Botev et al. (2017) is orders of magnitude more expensive to compute than the KFAC of Martens $\&$ Grosse (2015) on CIFAR-100, it was not included in the main plot. This is not an implementation error; it follows from the definition of those methods. To approximate the GGN, $\begin{array} { r } { \dot { G } ( \dot { \theta ) = } \sum _ { n } [ \mathrm { J } _ { \theta } f _ { n } ] ^ { \top } \nabla _ { f _ { n } } ^ { 2 } \ell _ { n } \left[ \mathrm { J } _ { \theta } f _ { n } \right] , } \end{array}$ , KFAC uses a rank-1 approximation for each of the inner Hessian $\nabla _ { f _ { n } } ^ { 2 } \ell _ { n } = \mathbf { { s } } _ { n } \mathbf { { s } } _ { n } ^ { \top }$ , and needs to propagate a vector through the computation graph for each sample. KFLR uses the complete inner Hessian instead. For CIFAR-100, the network has 100 output nodes—one for each class—and the inner Hessians are $[ 1 0 0 \times 1 0 0 ]$ matrices. KFLR needs to propagate a matrix through the computation graph for each sample, which is $1 0 0 \times$ more expensive as shown in Fig. 8.
+
+![](images/87e4836e2dc875976ebee5f1bb42b3e020d8dd54cadb67e5804a4876f790758e.jpg)  
+Figure 8: KFLR and DiagGGN are more expensive to run on large networks. The gradient takes less than $2 0 \mathrm { m s }$ to compute, but KFLR and DiagGGN are approximately $1 0 0 \times$ more expensive.
+
+Diagonal of the GGN vs. Diagonal of the Hessian: Most networks used in deep learning use ReLU activation functions. ReLU functions have no curvature as they are piecewise linear. Because of this, the diagonal of the GGN is equivalent to the diagonal of the Hessian (Martens, 2014). However, for networks that use non piecewise linear activation functions like sigmoids or tanh, computing the Hessian diagonal can be much more expensive than the GGN diagonal. To illustrate this point, we modify the smaller network used in our benchmarks to include a single sigmoid activation function before the last classification layer. The results in Fig. 9 show that the computation of the diagonal of the Hessian is already an order of magnitude more expensive than for the GGN.
+
+![](images/1475a0ee97a838dca4322bbd81a11365906d4e352a4595cd4092166f640dbb77.jpg)  
+Figure 9: Diagonal of the Hessian vs. the GGN. If the network contains a single sigmoid activation function, the diagonal of the Hessian is an order of magnitude more computationally intensive than the diagonal of the GGN.
+
+# C ADDITIONAL DETAILS ON EXPERIMENTS
+
+# C.1 PROTOCOL
+
+The optimizer experiments are performed according to the protocol suggested by DEEPOBS:
+
+• Train the neural network with the investigated optimizer and vary its hyperparameters on a specified grid. This training is performed for a single random seed only. DEEPOBS evaluates metrics during the training procedure. From all runs of the grid search, it selects the best run automatically. The results shown in this work were obtained with the default strategy, favoring highest final accuracy on the validation set. For a better understanding of the optimizer performance with respect to randomized routines in the training process, DEEPOBS reruns the best hyperparameter setting for ten different random seeds. The results show mean values over these repeated runs, with standard deviations as uncertainty indicators. Along with the benchmarked optimizers, we show the DEEPOBS base line performances for Adam and momentum SGD (Momentum). They are provided by DEEPOBS.
+
+The optimizers built upon BACKPACK’s curvature estimates were benchmarked on the DEEPOBS image classification problems summarized in Table 2.
+
+Table 2: Test problems considered from the DEEPOBS library (Schneider et al., 2019).   
+
+<table><tr><td>Codename</td><td>Description</td><td>Dataset</td><td>#Parameters</td></tr><tr><td>LOGREG</td><td>Linear model</td><td>MNIST</td><td>7,850</td></tr><tr><td>2C2D</td><td>2 convolutional and 2 dense linear layers</td><td>FASHION-MNIST</td><td>3,274,634</td></tr><tr><td>3C3D</td><td>3convolutional and 3 dense linear layers</td><td>CIFAR-10</td><td>895,210</td></tr><tr><td>ALL-CNN-C</td><td>9 convolutional layers (Springenberg et al.,2015)</td><td>CIFAR-100</td><td>1,387,108</td></tr></table>
+
+# C.2 GRID SEARCH AND BEST HYPERPARAMETER SETTING
+
+Both the learning rate $\alpha$ and damping $\lambda$ are tuned over the grid
+
+$$
+\alpha \in \left\{ 1 0 ^ { - 4 } , 1 0 ^ { - 3 } , 1 0 ^ { - 2 } , 1 0 ^ { - 1 } , 1 \right\} , \quad \lambda \in \left\{ 1 0 ^ { - 4 } , 1 0 ^ { - 3 } , 1 0 ^ { - 2 } , 1 0 ^ { - 1 } , 1 , 1 0 \right\} .
+$$
+
+We use the same batch size $N = 1 2 8$ for all problems, except $N = 2 5 6$ for ALL-CNN-C on CIFAR-100) as the base lines and the optimizers run for the identical number of epochs.
+
+The best hyperparameter settings are summarized in Table 3.
+
+# C.3 UPDATE RULE
+
+We use a simple update rule with a constant damping parameter $\lambda$ . Consider the parameters $\pmb \theta$ of a single module in a neural network with $\ell _ { 2 }$ -regularization of strength $\eta$ . Let $G ( \theta _ { t } )$ denote the curvature matrix and $\nabla _ { \pmb { \theta } } \mathcal { L } ( \pmb { \theta } _ { t } )$ the gradient at step $t$ . One iteration of the optimizer applies
+
+$$
+\pmb \theta _ { t + 1 } \gets \pmb \theta _ { t } + \left[ \pmb { G } ( \pmb \theta _ { t } ) + ( \lambda + \eta ) \pmb { I } ) \right] ^ { - 1 } \left[ \nabla _ { \theta } \mathcal { L } ( \pmb \theta _ { t } ) + \eta \pmb \theta _ { t } \right] .
+$$
+
+The inverse cannot be computed exactly (in reasonable time) for the Kronecker-factored curvatures KFAC, KFLR, and KFRA. We use the scheme of Martens $\&$ Grosse (2015) to approximately invert $G ( \pmb { \theta } _ { t } ) \mathrel { + } ( \lambda \mathrm { + } \eta ) \pmb { I }$ if $G ( \theta _ { t } )$ is Kronecker-factored; $G ( \pmb { \theta } _ { t } ) = A ( \pmb { \theta } _ { t } ) { \otimes } B ( \pmb { \theta } _ { t } )$ . It replaces the expression $( \lambda + \theta ) I$ by diagonal terms added to each Kronecker factor. In summary, this replaces
+
+$$
+\left[ A ( \pmb \theta _ { t } ) \otimes B ( \pmb \theta _ { t } ) + ( \lambda + \eta ) \pmb { I } \right] ^ { - 1 } \mathrm { b y } \left[ A ( \pmb \theta _ { t } ) + \pi _ { t } \sqrt { \lambda + \eta } \pmb I \right] ^ { - 1 } \otimes \left[ B ( \pmb \theta _ { t } ) + \frac { 1 } { \pi _ { t } } \sqrt { \lambda + \eta } \pmb I \right] ^ { - 1 } 
+$$
+
+A principled choice for the parameter $\pi _ { t }$ is given by $\pi _ { t } = \sqrt { \frac { \lVert A ( \pmb \theta _ { t } ) \otimes { \pmb I } _ { B } \rVert } { \lVert { \pmb I } _ { A } \otimes { \pmb B } ( \pmb \theta _ { t } ) \rVert } }$ for an arbitrary matrix norm $\lVert \cdot \rVert$ . We follow Martens & Grosse (2015) and choose the trace norm,
+
+$$
+\pi _ { t } = \sqrt { \frac { \operatorname { t r } ( A ( \pmb \theta _ { t } ) ) \operatorname { d i m } ( \pmb B ) } { \operatorname { d i m } ( A ) \otimes \operatorname { t r } ( \pmb B ( \pmb \theta _ { t } ) ) } } .
+$$
+
+Table 3: Best hyperparameter settings for optimizers and baselines shown in this work. In the Momentum baselines, the momentum was fixed to 0.9. Parameters for computation of the running averages in Adam use the default values $( \beta _ { 1 } , \beta _ { 2 } ) = ( 0 . 9 , 0 . 9 9 9 )$ . The symbols $\checkmark$ and $\pmb { \chi }$ denote whether the hyperparameter setting is an interior point of the grid or not, respectively.
+
+<table><tr><td rowspan="2">Curvature</td><td colspan="3">mnist-logreg</td><td colspan="3">fmnist_2c2d</td><td colspan="3">cifar10-3c3d</td><td colspan="3">cifar100_allcnnc</td></tr><tr><td>α</td><td>入</td><td>int</td><td>α</td><td>入</td><td>int</td><td>α</td><td>入</td><td>int</td><td>α</td><td>入</td><td>int</td></tr><tr><td>DiagGGN</td><td>10-3</td><td>10-3</td><td>√</td><td>10-4</td><td>10-4</td><td>X</td><td>10-3</td><td>10-2</td><td>√</td><td>-</td><td>1</td><td>-</td></tr><tr><td>DiagGGN-MC</td><td>10-3</td><td>10-3</td><td>√</td><td>10-4</td><td>10-4</td><td>X</td><td>10-3</td><td>10-2</td><td>√</td><td>10-3</td><td>10-3</td><td>√</td></tr><tr><td>KFAC</td><td>10-2</td><td>10-2</td><td>√</td><td>10-3</td><td>10-3</td><td>√</td><td>1</td><td>10</td><td>X</td><td>1</td><td>1</td><td>√</td></tr><tr><td>KFLR</td><td>10-2</td><td>10-2</td><td>√</td><td>10-2</td><td>10-3</td><td>√</td><td>1</td><td>10</td><td>X</td><td>1</td><td>1</td><td>1</td></tr><tr><td>KFRA</td><td>10-2</td><td>10-2</td><td>√</td><td>-</td><td>1</td><td>-</td><td>1</td><td>=</td><td>-</td><td>=</td><td>-</td><td>=</td></tr><tr><td>Baseline</td><td colspan="3">a</td><td colspan="3">α</td><td colspan="3">α</td><td colspan="3">α</td></tr><tr><td>Momentum</td><td colspan="3">~2.07:10-2</td><td colspan="3">~2.07:10-2</td><td colspan="3">~3.79.10-3</td><td colspan="3">~4.83:10-1</td></tr><tr><td>Adam</td><td colspan="3">~2.98.10-4</td><td colspan="3">≈1.27·10-4</td><td colspan="3">~2.98:10-4</td><td colspan="3">~6.95:10-4</td></tr></table>
+
+# C.4 ADDITIONAL RESULTS
+
+This section presents the results for MNIST using a logistic regression in Fig. 10 and FASHIONMNIST using the 2C2D network, composed of two convolution and two linear layers, in Fig. 11.
+
+![](images/92bcb6d2a2944a37868d17d24063e55a839d77769cb312eda6e417d07dfdc9ba.jpg)  
+Figure 10: Median performance with shaded quartiles of the best hyperparameter settings chosen by DEEPOBS for logistic regression (7,850 parameters) on MNIST. Solid lines show well-tuned baselines of momentum SGD and Adam that are provided by DEEPOBS.
+
+![](images/1facdd6112db0e172fb30a8d3a12f7cc62c751f5d58c8717ccc0abc9422d245a.jpg)  
+Figure 11: Median performance with shaded quartiles of the best hyperparameter settings chosen by DEEPOBS for the 2C2D network (3,274,634 parameters) on FASHION-MNIST. Solid lines show well-tuned baselines of momentum SGD and Adam that are provided by DEEPOBS.
+
+# D BACKPACK CHEAT SHEET
+
+• Assumptions – Feedforward network $z _ { n } ^ { ( 0 ) } \xrightarrow { T _ { \theta ^ { ( 1 ) } } ^ { ( 1 ) } ( z _ { n } ^ { ( 0 ) } ) } z _ { n } ^ { ( 1 ) } \xrightarrow { T _ { \theta ^ { ( 2 ) } } ^ { ( 2 ) } ( z _ { n } ^ { ( 1 ) } ) } . . . \xrightarrow { T _ { \theta ^ { ( L ) } } ^ { ( L ) } ( z _ { n } ^ { ( L - 1 ) } ) } z ^ { ( L ) } \xrightarrow { \ell ( z _ { n } ^ { ( L ) } , y ) } \ell ( \theta )$ – $\boldsymbol d ^ { ( i ) }$ : Dimension of parameter $\pmb \theta ^ { ( i ) }$ – Empirical risk $\begin{array} { r } { \mathcal { L } ( \pmb { \theta } ) = \frac { 1 } { N } \sum _ { n = 1 } ^ { N } \ell ( f ( \pmb { \theta } , \pmb { x } _ { n } ) , \pmb { y } _ { n } ) } \end{array}$
+
+• Shorthands
+
+$$
+\begin{array} { r l } & { \ell _ { n } ( \pmb \theta ) = \ell ( f ( \pmb \theta , \pmb x _ { n } ) , \pmb y _ { n } ) , \qquad n = 1 , \dots , N , } \\ & { f _ { n } ( \pmb \theta ) = f ( \pmb \theta , \pmb x _ { n } ) = z _ { n } ^ { ( L ) } ( \pmb \theta ) , \qquad n = 1 , \dots , N } \end{array}
+$$
+
+• Generalized Gauss-Newton matrix
+
+$$
+\boldsymbol { G } ( \theta ) = \frac { 1 } { N } \sum _ { n = 1 } ^ { N } ( \mathrm { J } _ { \theta } f _ { n } ) ^ { \top } \nabla _ { f _ { n } } ^ { 2 } \ell _ { n } ( \theta ) ( \mathrm { J } _ { \theta } f _ { n } )
+$$
+
+• Approximative GGN via MC sampling
+
+$$
+\tilde { G } ( \theta ) = \frac { 1 } { N } \sum _ { n = 1 } ^ { N } ( \mathrm { J } _ { \theta } f _ { n } ) ^ { \top } \left[ \nabla _ { \theta } \ell ( f _ { n } ( \theta ) , \hat { y } ) \nabla _ { \theta } \ell ( f _ { n } ( \theta ) , \hat { y } _ { n } ) ^ { \top } \right] _ { \hat { y } _ { n } \sim p _ { f _ { n } ( \mathbf { x } _ { n } ) } } ( \mathrm { J } _ { \theta } f _ { n } )
+$$
+
+Table 4: Overview of the features supported in the first release of BACKPACK. The quantities are computed separately for all module parameters, i.e. $i = 1 , \ldots , L$ .   
+
+<table><tr><td>Feature</td><td>Details</td></tr><tr><td>Individual gradients</td><td>NVen(0）， n=1..,N</td></tr><tr><td>Batch variance</td><td>j=1.,...,d(i)</td></tr><tr><td>2nd moment</td><td>N≥m1N0oen(0)l，j=1do).</td></tr><tr><td>Indiv. gradient l2 norm</td><td>|/∀θ(i)len(0)l²， n =1,...,N</td></tr><tr><td>DiagGGN</td><td>diag (G(0())</td></tr><tr><td>DiagGGN-MC</td><td>diag(G(0())</td></tr><tr><td>Hessian diagonal</td><td>diag(V() C（0))</td></tr><tr><td>KFAC</td><td>G(0(i)~Ai) B KFAC</td></tr><tr><td>KFLR</td><td>G(0(𝑖)) ≈ A(i) 区 B KFLR （i）</td></tr><tr><td>KFRA</td><td>G(0(i)) ~ Ai1 B KFRA</td></tr></table>

parse/train/Bk8BvDqex/Bk8BvDqex.md

@@ -0,0 +1,371 @@
+# METACONTROL FOR ADAPTIVE IMAGINATION-BASED OPTIMIZATION
+
+Jessica B. Hamrick UC Berkeley & DeepMind jhamrick@berkeley.edu
+
+Andrew J. Ballard DeepMind aybd@google.com
+
+Razvan Pascanu DeepMind razp@google.com
+
+Oriol Vinyals   
+DeepMind   
+vinyals@google.com   
+Nicolas Heess   
+DeepMind   
+heess@google.com   
+Peter W. Battaglia   
+DeepMind   
+peterbattaglia@google.com
+
+# ABSTRACT
+
+Many machine learning systems are built to solve the hardest examples of a particular task, which often makes them large and expensive to run—especially with respect to the easier examples, which might require much less computation. For an agent with a limited computational budget, this “one-size-fits-all” approach may result in the agent wasting valuable computation on easy examples, while not spending enough on hard examples. Rather than learning a single, fixed policy for solving all instances of a task, we introduce a metacontroller which learns to optimize a sequence of “imagined” internal simulations over predictive models of the world in order to construct a more informed, and more economical, solution. The metacontroller component is a model-free reinforcement learning agent, which decides both how many iterations of the optimization procedure to run, as well as which model to consult on each iteration. The models (which we call “experts”) can be state transition models, action-value functions, or any other mechanism that provides information useful for solving the task, and can be learned on-policy or off-policy in parallel with the metacontroller. When the metacontroller, controller, and experts were trained with “interaction networks” (Battaglia et al., 2016) as expert models, our approach was able to solve a challenging decision-making problem under complex non-linear dynamics. The metacontroller learned to adapt the amount of computation it performed to the difficulty of the task, and learned how to choose which experts to consult by factoring in both their reliability and individual computational resource costs. This allowed the metacontroller to achieve a lower overall cost (task loss plus computational cost) than more traditional fixed policy approaches. These results demonstrate that our approach is a powerful framework for using rich forward models for efficient model-based reinforcement learning.
+
+# 1 INTRODUCTION
+
+While there have been significant recent advances in deep reinforcement learning (Mnih et al., 2015; Silver et al., 2016) and control (Lillicrap et al., 2015; Levine et al., 2016), most efforts train a network that performs a fixed sequence of computations. Here we introduce an alternative in which an agent uses a metacontroller to choose which, and how many, computations to perform. It “imagines” the consequences of potential actions proposed by an actor module, and refines them internally, before executing them in the world. The metacontroller adaptively decides which expert models to use to evaluate candidate actions, and when it is time to stop imagining and act. The learned experts may be state transition models, action-value functions, or any other function that is relevant to the task, and can vary in their accuracy and computational costs. Our metacontroller’s learned policy can exploit the diversity of its pool of experts by trading off between their costs and reliability, allowing it to automatically identify which expert is most worthwhile.
+
+We draw inspiration from research in cognitive science and neuroscience which has studied how people use a meta-level of reasoning in order to control the use of their internal models and allocation of their computational resources. Evidence suggests that humans rely on rich generative models of the world for planning (Glascher et al., 2010), control (Wolpert & Kawato, 1998), and reasoning ¨ (Hegarty, 2004; Johnson-Laird, 2010; Battaglia et al., 2013), that they adapt the amount of computation they perform with their model to the demands of the task (Hamrick et al., 2015), and that they trade off between multiple strategies of varying quality (Lee et al., 2014; Lieder et al., 2014; Lieder & Griffiths, in revision; Kool et al., in press).
+
+Our imagination-based optimization approach is related to classic artificial intelligence research on bounded-rational metareasoning (Horvitz, 1988; Russell & Wefald, 1991; Hay et al., 2012), which formulates a meta-level MDP for selecting computations to perform, where the computations have a known cost. We also build on classic work by Schmidhuber (1990a;b), which used an RL controller with a recurrent neural network (RNN) world model to evaluate and improve upon candidate controls online.
+
+Recently Andrychowicz et al. (2016) used a fully differentiable deep network to learn to perform gradient descent optimization, and Tamar et al. (2016) used a convolutional neural network for performing value iteration online in a deep learning setting. In other similar work, Fragkiadaki et al. (2015) made use of “visual imaginations” for action planning. Our work is also related to recent notions of “conditional computation” (Bengio, 2013; Bengio et al., 2015), which adaptively modifies network structure online, and “adaptive computation time” (Graves, 2016) which allows for variable numbers of internal “pondering” iterations to optimize computational cost.
+
+Our work’s key contribution is a framework for learning to optimize via a metacontroller which manages an adaptive, imagination-based optimization loop. This represents a hybrid RL system where a model-free metacontroller constructs its decisions using an actor policy to manage model-free and model-based experts. Our experimental results demonstrate that a metacontroller can flexibly allocate its computational resources on a case-by-case basis to achieve greater performance than more rigid fixed policy approaches, using more computation when it is required by a more difficult task.
+
+# 2 MODEL
+
+We consider a class of fully observed, one-shot decision-making tasks (i.e., continuous, contextual bandits). The performance objective is to find a control $c \in { \mathcal { C } }$ which, given an initial state $x \in \mathcal { X }$ , minimizes some loss function $\mathcal { L }$ between a known future goal state $x ^ { * }$ and the result of a forward process, $f ( x , c )$ . The performance loss $L _ { P }$ is the (negative) utility of executing the control in the world, and is related to the optimal solution $c ^ { * } \in \mathcal { C }$ as follows:
+
+$$
+\begin{array} { c } { { L _ { P } ( x ^ { * } , x , c ) = \mathcal { L } ( x ^ { * } , f ( x , c ) ) , } } \\ { { c ^ { * } = \arg \underset { c } { \operatorname* { m i n } } L _ { P } ( x ^ { * } , x , c ) . } } \end{array}
+$$
+
+However, (2) defines only the optimal solution—not how to achieve it.
+
+# 2.1 OPTIMIZING PERFORMANCE
+
+We consider an iterative optimization procedure that takes $x ^ { * }$ and $x$ as input and returns an approximation of $c ^ { * }$ in order to minimize (1). The optimization procedure consists of a controller, which iteratively proposes controls, and an expert, which evaluates how good those controls are. On the $n ^ { \mathrm { t h } }$ iteration, the controller $\pi ^ { C } : \mathcal { X } \times \bar { \mathcal { X } } \times \mathcal { H }  \mathcal { C }$ takes as input, $x ^ { * } , x$ , and information about the history of previously proposed controls and evaluations $h _ { n - 1 } \in \mathcal { H }$ , and returns a proposed control $c _ { n }$ that aims to improve on previously proposed controls. An expert $E : \mathcal { X } \times \mathcal { X } \times \mathcal { C }  \mathcal { E }$ takes the proposed control and provides some information $e _ { n } \in \mathcal { E }$ about the quality of the control, which we call an opinion. This opinion is added to the history, which is passed back to the controller, and the loop continues for $N$ steps, after which a final control $c _ { N }$ is proposed.
+
+Standard optimization methods use principled heuristics for proposing controls. In gradient descent, for example, controls are proposed by adjusting $c _ { n }$ in the direction of the gradient of the reward with respect to the control. In Bayesian optimization, controls are proposed based on selection criteria such as “probability of improvement”, or a meta-selection criterion for choosing among several basic selection criteria Hoffman et al. (2011); Shahriari et al. (2014). Rather than choosing one of several controllers, our work learns a single controller and instead focuses on selecting from multiple experts (see Sec. 2.2). In some cases $f$ is known and inexpensive to compute, and thus the optimization procedure sets $E \equiv f$ . However, in many real-world settings, $f$ is expensive or non-stationary and so it can be advantageous to use an approximation of $f$ (e.g., a state transition model), $L _ { P }$ (e.g., an action-value function), or any other quantity that gives some information about $f$ or $L _ { P }$ .
+
+![](images/5077114dd725c83f96264d4f04d8e1fdaa7410cd08391efd84cf3d40864acd8e.jpg)  
+Figure 1: Metacontroller architecture and task. A: All components are part of the metacontroller agent (box) except the scene and the world, which are part of the agent’s environment. The manager takes the scene and history and determines which action to take (i.e., whether to execute or ponder, and with what expert to ponder with), denoted by the orange lines. The controller takes the scene and history and computes a control (e.g., the force to apply to a spaceship), denoted by the blue lines. The orange line ending with a circle at the switch reflects the fact that the manager’s action affects the behavior of the switch, which routes the controller’s control to either an expert (e.g., a simulation model of the spaceship’s trajectory, an action-value function, etc.) or the world. The outcome and reward from the expert, along with the history, action, and control, are fed into the memory, which produces the next history. The history is fed back to the controller on the next iteration in order to allow it to propose controls based on what it has already tried. B-C: Scenes consisted of a number of planets (depicted here by colored circles) of different masses as well as a spaceship (also with a variable mass). The task was to apply a force to the spaceship for one time step of simulation (depicted here as a solid red arrow) such that the resulting trajectory (dotted red arrow) would put the spaceship at a target (bullseye) after 11 steps of simulation. The white ring of the bullseye corresponds to a performance loss of 0.12-0.15, the black ring to a loss of 0.09-0.12, the blue ring to a loss of 0.06-0.09, the red ring to a loss of 0.03-0.06, and the yellow center to a loss of 0.03 or less. B depicts an easy, 1-planet scene, while C depicts a very difficult 5-planet scene.
+
+# 2.2 OPTIMIZING COMPUTATIONAL COST
+
+Given a controller and one or more experts, there are two important decisions to be made. First, how many optimization iterations should be performed? The approximate solution usually improves with more iterations, but each iteration costs computational resources. However, most traditional optimizers either ignore the cost of computation or select the number of iterations using simple heuristics. Because they do not balance the cost of computation against the performance loss, the overall effectiveness of these approaches is subject to the skill and preferences of the practitioners who use them. Second, which expert should be used on each step of the optimization? Some experts may be accurate but expensive to compute in terms of time, energy and/or money, while others may be crude, yet cheap. Moreover, the reliability of the experts may not be known a priori, further limiting the effectiveness of the optimization procedure. Our use of a metacontroller address these issues by jointly optimizing over the choices of how many steps to take and which experts to use.
+
+We consider a family of optimizers which use the same controller, $\pi ^ { C }$ , but vary in their expert evaluators, $\{ E _ { 1 } , \ldots , E _ { K } \}$ . Assuming that the controller and experts are deterministic functions, the number of iterations $N$ and the sequences of experts ${ \bf k } = \left( k _ { 1 } , \ldots , k _ { N - 1 } \right)$ exactly determine the final control and performance loss $L _ { P }$ . This means we have transformed the performance optimization over $c$ into an optimization over $N$ and $\mathbf { k }$ : $\begin{array} { r } { ( N , { \mathbf k } ) ^ { * } = \arg \operatorname* { m i n } _ { k , n } L _ { P } ( x ^ { * } , x , c ( N , { \mathbf k } , x , \bar { x } ^ { * } ) ) } \end{array}$ , where the notation $c ( N , \mathbf { k } , x , x ^ { * } )$ is used to emphasize that the control is a function $N , \mathbf { k } , x$ , and $x ^ { * }$ .
+
+If each optimizer has an associated computational cost $\tau _ { k }$ , then $N$ and $\mathbf { k }$ also exactly determine the computational resource loss of the optimization run, $\begin{array} { r } { L _ { R } ( N , \mathbf { k } ) = \sum _ { n = 1 } ^ { N - 1 } { \tau _ { k _ { n } } } . } \end{array}$ . The total loss is then the sum of $L _ { P }$ and $L _ { R }$ , each of which are functions of $N$ and $\mathbf { k }$ ,
+
+$$
+\begin{array} { l } { { \displaystyle { \cal L } _ { T } ( x ^ { * } , x , N , { \bf k } ) = { \cal L } _ { P } ( x ^ { * } , x , c ( N , { \bf k } , x , x ^ { * } ) ) + { \cal L } _ { R } ( N , { \bf k } ) } } \\ { { \displaystyle ~ = { \cal L } ( x ^ { * } , f ( x , \pi ^ { C } ( x ^ { * } , x , h _ { N - 1 } ) ) ) + \sum _ { n = 1 } ^ { N - 1 } \tau _ { k _ { n } } , } } \end{array}
+$$
+
+and the optimal solution is defined as $( N , { \bf k } ) ^ { * } = \arg \operatorname* { m i n } _ { N , { \bf k } } L _ { T } ( x ^ { * } , x , N , { \bf k } )$ . Optimizing $L _ { T }$ is difficult because of the recursive dependency on the history, $h _ { N - 1 }$ , and because the discrete choices of $N$ and $\mathbf { k }$ mean $L _ { T }$ is not differentiable.
+
+To optimize $L _ { T }$ we recast it as an RL problem where the objective is to jointly optimize task performance and computational cost. As shown in Figure 1a, the metacontroller agent $a ^ { M }$ is comprised of a controller $\bar { \pi } ^ { C }$ , a pool of experts $\{ E _ { 1 } , \ldots , E _ { K } \}$ , a manager $\pi ^ { M }$ , and a memory $\mu$ . The manager is a meta-level policy (Russell & Wefald, 1991; Hay et al., 2012) over actions indexed by $k$ , which determine whether to terminate the optimization procedure $k = 0$ ) or to perform another iteration of the optimization procedure with the $k ^ { \mathrm { { t h } } }$ expert. Specifically, on the $n ^ { \mathrm { { \hat { t } h } } }$ iteration the controller produces a new control $c _ { n }$ based on the history of controls, experts, and evaluations. The manager, also relying on this history, independently decides whether to end the optimization procedure (i.e., to execute the control in the world) or to perform another iteration and evaluate the proposed control with the $k _ { n } ^ { \mathrm { t h } }$ expert (i.e., to ponder, after Graves (2016)). The memory then updates the history $h _ { n }$ by concatenating $k$ , $c _ { n }$ , and $e _ { n }$ with the previous history $h _ { n - 1 }$ . Coming back to the notion of imagination-based optimization, we suggest that this iterative optimization process is analogous to imagining what will happen (using one or more approximate world models) before actually executing that action in the world. For further details, see Appendix A, and for an algorithmic illustration of the metacontroller agent, see Algorithm 1 in the appendix.
+
+We also define two special cases of the metacontroller for baseline comparisons. The iterative agent $a ^ { I }$ does not have a manager and uses only a single expert. Its number of iterations are pre-set to a single $N$ . The reactive agent, $a ^ { 0 }$ , is a special case of the iterative agent, where the number of iterations is fixed to $N = 0$ . This implies that proposed controls are executed immediately in the world, and are not evaluated by an expert. For algorithmic illustrations of the iterative and reactive agents, see Algorithms 2 and 3 in the appendix.
+
+# 2.3 NEURAL NETWORK IMPLEMENTATION
+
+We use standard deep learning building blocks, e.g., multi-layer perceptrons (MLPs), RNNs, etc., to implement the controller, experts, manager, and memory, because they are effective at approximating complex functions via gradient-based and reinforcement learning, but other approaches could be used as well. In particular, we constructed our implementation to be able to make control decisions in complex dynamical systems, such as controlling the movement of a spaceship (Figure 1b-c), though we note that our approach is not limited to such physical reasoning tasks. Here we used mean-squared error (MSE) for our $\mathcal { L }$ and Adam (Kingma & Ba, 2014) as the training optimizer.
+
+Experts We implemented the experts as MLPs and “interaction networks” (INs) (Battaglia et al., 2016), which are well-suited to predicting complex dynamical systems like those in our experiments below. Each expert has parameters $\theta ^ { E _ { k } }$ , i.e. $\overset { \cdot } { e } _ { n } = \overset { \cdot } { E } _ { k } \left( x ^ { * } , x , \overset { \cdot } { c } _ { n } ; \theta ^ { E _ { k } } \right)$ , and may be trained either on-policy using the outputs of the controller (as is the case in this paper), or off-policy by any data that pairs states and controls with future states or reward outcomes. The objective $L _ { E _ { k } }$ for each expert may be different depending on what the expert outputs. For example, the objective could be the loss between the goal and future states, ${ L _ { E _ { k } } } ^ { \setminus } = \mathcal { L } \left( \hat { f } ( x , c ) , E _ { k } ( x ^ { \ast } , \overset { \cdot } { x } , c ; \theta ^ { E _ { k } } ) \right)$ , which is what we use in our experiments. Or, it could be the loss between $L _ { P }$ and an action-value function that predicts $L _ { P }$ directly, $L _ { E _ { k } } = \mathcal { L } \left( L _ { P } ( x ^ { * } , x , c ) , E _ { k } ( x ^ { * } , x , c ; \theta ^ { E _ { k } } ) \right)$ . See Appendix B.1 for details.
+
+Controller and Memory We implemented the controller as an MLP with parameters $\theta ^ { C }$ , i.e. $c _ { n } =$ $\pi ^ { C } ( x ^ { * } , x , h _ { n - 1 } ; \theta ^ { C } )$ , and we implemented the memory as a Long Short-Term Memory (LSTM) (Hochreiter & Schmidhuber, 1997) with parameters $\theta ^ { \mu }$ . The memory embeds the history as a fixedlength vector, i.e. $h _ { n } \ = \ \mu ( h _ { n - 1 } , k _ { n } , c _ { n } , E _ { k _ { n } } ( x ^ { * } , x , c _ { n } ) ; \theta ^ { \mu } )$ . The controller and memory were trained jointly to optimize (1). However, this objective includes $f$ , which is often unknown or not differentiable. We overcame this by approximating $L _ { P }$ with a differentiable critic analogous to those used in policy gradient methods (e.g. Silver et al., 2014; Lillicrap et al., 2015; Heess et al., 2015). See Appendices B.2 and B.3 for details.
+
+Manager We implemented the manager as a stochastic policy that samples from a categorical distribution whose weights are produced by an MLP with parameters $\theta ^ { M }$ , i.e. $k _ { n } ~ \sim$ Categorical $( k ; \pi ^ { M } ( x ^ { * } , x , h _ { n - 1 } ; \theta ^ { M } ) )$ . We trained the manager to minimize (3) using REINFORCE (Williams, 1992), but other deep RL algorithms could be used instead. See Appendix B.4 for details.
+
+# 3 EXPERIMENTS
+
+To evaluate our metacontroller agent, we measured its ability to learn to solve a class of physicsbased tasks that are surprisingly challenging. Each episode consisted of a scene which contained a spaceship and multiple planets (Figure 1b-c). The spaceship’s goal was to rendezvous with its mothership near the center of the system in exactly 11 time steps, but it only had enough fuel to fire its thrusters once. The planets were static but the gravitational force they exerted on the spacecraft induced complex non-linear dynamics on the motion over the 11 steps. The spacecraft’s action space was continuous, up to some maximum magnitude, and represented the instantaneous Cartesian velocity vector imparted by its thrusters. Further details are in Appendix C.
+
+We trained the reactive, iterative, and metacontroller agents on five versions of the spaceship task involving different numbers of planets.1 The iterative agent was trained to take anywhere from zero (i.e., the reactive agent) to ten ponder steps. The metacontroller was allowed to take a maximum of ten ponder steps. We considered three different experts which were all differentiable: an MLP expert which used an MLP to predict the final location of the spaceship, an IN expert which used an interaction network (Battaglia et al., 2016) to predict the full trajectory of the spaceship, and a true simulation expert which was the same as the world model. In some conditions the metacontroller could use exactly one expert and in others it was allowed to select between the MLP and IN experts. For experiments with the true simulation expert, we used it to backpropagate gradients to the controller and memory. For experiments with an MLP as the only expert, we used a learned IN as the critic. For experiments with an IN as one of its experts, the critic was an IN with shared parameters. We trained the metacontroller on a range of different ponder costs, $\tau _ { k }$ , for the different experts. Further details of the training procedure are available in Appendix D.
+
+# 3.1 REACTIVE AND ITERATIVE AGENTS
+
+Figure 2 shows the performance on the test set of the reactive and iterative agents for different numbers of ponder steps. The reactive agent performed poorly on the task, especially when the task was more difficult. With the five planets dataset, it was only able to achieve a performance loss of 0.583 on average (see Figure 1 for a depiction of the magnitude of the loss). In contrast, the iterative agent with the true simulation expert performed much better, reaching ceiling performance on the datasets with one and two planets, and achieving a performance loss of 0.0683 on the five planets dataset. The IN and MLP experts also improve over the reactive agent, with a minimum performance loss of 0.117 and 0.375 on the five planets dataset, respectively.
+
+![](images/41111728dd90fe2a84e76ff9a4323071f215bd31b97658550ad195b104e2ae7b.jpg)  
+Figure 2: Test performance of the reactive and iterative agents. Each line corresponds to the performance of an iterative agent (either the true simulation expert, the MLP expert, or the interaction net expert) trained for a fixed number of ponder steps on one of the five datasets; the line color indicates which dataset the controller was trained on. In all cases, performance refers to the performance loss, $L _ { P }$ . Left: the MLP expert struggles with the task due to its limited expressivity, but still benefits from pondering. Middle: the IN expert performs almost as well as the true simulation expert, even though it is not a perfect model. Right: The true simulation expert does quite well on the task, especially with multiple ponder steps.
+
+Figure 2 also highlights how important the choice of expert is. When using the true simulation and IN experts, the iterative agent performs well. With the MLP expert, however, performance is substantially diminished. But despite the poor performance of the MLP expert, there is still some benefit of pondering with it. With even just a few steps, the MLP iterative agent outperforms its reactive counterpart. However comparing the reactive agent with the $N \ = \ 1$ iterative agent is somewhat unfair because the iterative agent has more parameters due to the expert and the memory. However, given that there tends to also be an increase in performance between one and two ponder steps (and beyond), it is clear that pondering—even with a highly inaccurate model—can still lead to better performance than a model-free reactive approach.
+
+# 3.2 METACONTROLLER WITH ONE EXPERT
+
+Though the iterative agents achieve impressive results, they expend more computation than necessary. For example, in the one and two planet conditions, the performances of the IN and true simulation iterative agents received little performance benefit from pondering more than two or three steps, while for the four and five planet conditions they required at least five to eight steps before their performance converged. When computational resources have no cost, the number of steps are of no concern, but when they have some cost it is important to be economical.
+
+Because the metacontroller learns to choose its number of pondering steps, it can balance its performance loss against the cost of computation. Figure 3 (top row, middle and right subplots) shows that the IN and true simulation expert metacontroller take fewer ponder steps as $\tau$ increases, tracking closely the minimum of the iterative agent’s cost curve (i.e., the metacontroller points are always near the iterative agent curves’ minima). This adaptive behavior emerges automatically from the manager’s learned policy, and avoids the need to perform a hyperparameter search to find the best number of iterations for a given $\tau$ .
+
+The metacontroller does not simply choose an average number of ponder steps to take per episode: it actually tailors this choice to the difficulty of each episode. Figure 4 shows how the number of ponder steps the IN metacontroller chooses in each episode depends on that episode’s difficulty, as measured by the episode’s loss under the reactive agent. For more difficult episodes, the metacontroller tends to take more ponder steps, as indicated by the positive slopes of the best fit lines, and this proportionality persists across the different levels of $\tau$ in each subplot.
+
+![](images/231d48311d5376805ceedfaa5e46d004f71815fbaa7b626cb305899692a67902.jpg)  
+Figure 3: Test performance of the metacontroller with a single expert on the five planets dataset. Each column corresponds to a different experts. The lines indicate the performance of the iterative agents for different numbers of ponder steps. The points indicate the performance of the metacontroller, with each point corresponding to a different value of $\tau$ . The $x$ -coordinate of each point is an average across the number of ponder steps, and the $y$ -coordinate is the average loss. Top row: Here we show total cost rather than just performance on the task (i.e., including computation cost). Different colors show the result for different $\tau$ , with the different lines showing the cost for the same iterative controller under different values of $\tau$ . The error bars (for the metacontroller) indicate $2 . 5 \%$ and $9 7 . 5 \%$ confidence intervals. When the point is below its corresponding curve, it means that the metacontroller was able to achieve a better speed-accuracy trade-off than that achievable by the iterative agent. Line colors of increasing brightness correspond to increasing $\tau$ , with $\tau$ values taken from [0, 0.0134, 0.0354, 0.0576, 0.0934, 0.152, 0.246]. Bottom row: Here we show just the performance loss (i.e., without computational cost). Each point corresponds to a different value of $\tau$ . The fact that the points are below the curve means the metacontroller agent learns to perform better than the iterative agent with the equivalent number of ponder steps.
+
+The ability to adapt its choice of number of ponder steps on a per-episode basis is very valuable because it allows the metacontroller to spend additional computation only on those episodes which require it. The total costs of the IN and true simulation metacontrollers’ are $11 \%$ and $15 \%$ lower (median) than the best achievable costs of their corresponding iterative agents, respectively, across the range of $\tau$ values we tested (see Figure 7 in the Appendix for details).
+
+There can even be a benefit to using a metacontroller when there are no computational resource costs. Consider the rightmost points in Figure 3 (bottom row, middle and right subplots), which show the performance loss for the IN and true simulation metacontrollers when $\tau$ is low. Remarkably, these points still outperform the best achievable iterative agents. This suggests that there can be an advantage to stopping pondering once a good solution is found, and more generally demonstrates that the metacontroller’s learning process can lead to strategies that are superior to those available to less flexible agents.
+
+The metacontroller with the MLP expert had very poor average performance and high variance on the five planet condition (Figure 3, top left subplot), which is why we restricted our focus in this section to how the metacontrollers with IN and true simulation experts behaved. The MLP’s poor performance is crucial, however, for the following section (3.3) which analyzes how a multipleexpert metacontroller manages experts which vary greater in their reliability.
+
+# 3.3 METACONTROLLER WITH TWO EXPERTS
+
+When we allow the manager to additionally choose between two experts, rather than only relying on a single expert, we find a similar pattern of results in terms of the number of ponder steps (Figure 5, left). Additionally, the metacontroller is successfully able to identify the more reliable IN network and consequently uses it a majority of the time, except in a few cases where the cost of the IN network is extremely high relative to the cost of the MLP network (Figure 5, right). This pattern of results makes sense given the good performance (described in the previous section) of the metacontroller with the IN expert compared to the poor performance of the metacontroller with the MLP expert. The manager should not generally rely on the MLP expert because it is simply not a reliable source of information.
+
+However, the metacontroller has more difficulty finding an optimal balance between the two experts on a step-by-step basis: the addition of a second expert did not yield much of an improvement over the single-expert metacontroller, with only $9 \%$ of the different versions (trained with different $\tau$ values for the two experts) achieving a lower loss than the best iterative controller. We believe the mixed performance of the metacontroller with multiple experts is partially due to an entropy term which we used to encourage the manager’s policy to be non-deterministic (see Appendix B.4). In particular, for high values of $\tau$ , the optimal thing to do is to always execute immediately without pondering. However, because of the entropy term, the manager is encourage to have a non-deterministic policy and therefore is likely to ponder more than it should—and to use experts that are more unreliable— even when this is suboptimal in terms of the total loss (3).
+
+Despite the fact that the metacontroller with multiple experts does not result in a substantial improvement over that which uses a single expert, we emphasize that the manager is able to identify and use the more reliable expert the majority of the time. And, it is still able to choose a variable number of steps according to how difficult the task is (Figure 5, left). This, in and of itself, is an improvement over more traditional optimization methods which would require that the expert is hand-picked ahead of time and that the number of steps are determined heuristically.
+
+![](images/67c79265dd64f414592dbeb6789acd1c30f3146af2281a4bf44029cffc79e79e.jpg)  
+Figure 4: Relationship between the number of ponder steps and per-episode difficulty for the IN metacontroller. Each subplot’s $x$ -axis represents the episode difficulty, as measured by the reactive controller’s loss. Each $y$ -axis represents the number of ponder steps the metacontroller took. The points are individual episodes, and the line is the best fit regression line and $9 5 \%$ confidence intervals. The different subplots show different values of $\tau$ (labeled in the title). In each case, there is a clear positive relationship between the difficulty of the task and the number of ponder steps, suggesting that the metacontroller learns to spend more time on hard problems and less time on easier problems. At the bottom of each plot are the fitted slope and correlation coefficient values, along with their $9 5 \%$ confidence intervals in brackets.
+
+![](images/6c27d35d31aee616bdd07de11338aa95cf66d53fc464c6d1815161a0c5a27379.jpg)  
+Figure 5: Test performance of the metacontroller with multiple experts on the five planets dataset. Left: The average number of total ponder steps, for different values of $\tau$ . As with the single-expert metacontrollers, fewer ponder steps are taken when the cost is very high, and more are taken when the cost is low. Right: The fraction of ponder steps taken by the MLP expert relative to the IN expert. In the majority of cases, the metacontroller favors using the IN expert as it is much more reliable. The few exceptions (red squares) are cases when the cost of the IN expert is much higher relative to the cost of the MLP expert.
+
+# 4 DISCUSSION
+
+In this paper, we have presented an approach to adaptive, imagination-based optimization in neural networks. Our approach is able to flexibly choose which computations to perform as well as how many computations need to be performed, approximately solving a speed-accuracy trade-off that depends on the difficulty of the task. In this way, our approach learns to rely on whatever source of information is most useful and most efficient. Additionally, by consulting the experts on-the-fly, our approach allows agents to test out actions to ensure that their consequences are not disastrous before actually executing them.
+
+While the experiments in this paper involve a one-shot decision task, our approach lays a foundation that can be built upon to support more complex situations. For example, rather than applying a force only on the first time step, we could turn the problem into one of trajectory optimization for continuous control by asking the controller to produce a sequence of forces. In the case of planning, our approach could potentially be combined with methods like Monte Carlo Tree-Search (MCTS) (Coulom, 2006), where our experts would be akin to having several different rollout policies to choose from, and our controller would be akin to the tree policy. While most MCTS implementations will run rollouts until a fixed amount of time has passed, our approach would allow the manager to adaptively choose the number of rollouts to perform and which policies to perform the rollouts with. Our method could also be used to naturally augment existing model-free approaches such as DQN (Mnih et al., 2015) with online model-based optimization by using the model-free policy as a controller and adding additional experts in the form of state-transition models. An interesting extension would be to compare our metacontroller architecture with a na¨ıve model-based controller that performs gradient-based optimization to produce the final control. We expect our metacontroller architecture might require fewer model evaluations and to be more robust to model inaccuracies compared to the gradient-based method, because our method has access to the full history of proposed controls and evaluations whereas traditional gradient-based methods do not.
+
+Although we rely on differentiable experts in our metacontroller architecture, we do not utilize the gradient information from these experts. An interesting extension to our work would be to pass this gradient information through to the manager and controller (as in Andrychowicz et al. (2016)), which would likely improve performance further, especially in the more complex situations discussed here. Another possibility is to train some or all of the experts inline with the controller and metacontroller, rather than independently, which could allow their learned functionality to be more tightly integrated with the rest of the optimization loop, at the expense of their generality and ability to be repurposed for other uses.
+
+To conclude, we have demonstrated how neural network-based agents can use metareasoning to adaptively choose what to think about, how to think about it, and for how long to think for. Our method is directly inspired by human cognition and suggests a way to make agents much more flexible and adaptive than they currently are, both in decision making tasks such as the one described here, as well as in planning and control settings more broadly.
+
+# ACKNOWLEDGMENTS
+
+We would like to thank Matt Hoffman, Andrea Tacchetti, Tom Erez, Nando de Freitas, Guillaume Desjardins, Joseph Modayil, Hubert Soyer, Alex Graves, David Reichert, Theo Weber, Jon Scholz, Will Dabney, and others on the DeepMind team for helpful discussions and feedback.
+
+# REFERENCES
+
+Marcin Andrychowicz, Misha Denil, Sergio Gomez, Matthew W Hoffman, David Pfau, Tom Schaul, and Nando de Freitas. Learning to learn by gradient descent by gradient descent. arXiv:1606.04474, 2016.   
+Peter Battaglia, Razvan Pascanu, Matthew Lai, Danilo Jimenez Rezende, and Koray Kavukcuoglu. Interaction networks for learning about objects, relations and physics. Advances in Neural Information Processing Systems, 2016.   
+Peter W. Battaglia, Jessica B. Hamrick, and Joshua B. Tenenbaum. Simulation as an engine of physical scene understanding. Proceedings of the National Academy of Sciences, 110(45):18327–18332, 2013.   
+Emmanuel Bengio, Pierre-Luc Bacon, Joelle Pineau, and Doina Precup. Conditional computation in neural networks for faster models. arXiv:1511.06297, 2015.   
+Yoshua Bengio. Deep learning of representations: Looking forward. arXiv:1305.0445, 2013.   
+Remi Coulom. Efficient selectivity and backup operators in monte-carlo tree search. In ´ International Conference on Computers and Games, pp. 72–83. Springer, 2006.   
+Katerina Fragkiadaki, Pulkit Agrawal, Sergey Levine, and Jitendra Malik. Learning Visual Predictive Models of Physics for Playing Billiards. Proceedings of the International Conference on Learning Representations (ICLR 2016), pp. 1–12, 2015. URL http://arxiv.org/abs/1511.07404.   
+Jan Glascher, Nathaniel Daw, Peter Dayan, and John P. O’Doherty. States versus rewards: Dissociable neural ¨ prediction error signals underlying model-based and model-free reinforcement learning. Neuron, 66(4):585 – 595, 2010.   
+Alex Graves. Adaptive computation time for recurrent neural networks. arXiv:1603.08983, 2016.   
+Jessica B. Hamrick, Kevin A. Smith, Thomas L. Griffiths, and Edward Vul. Think again? the amount of mental simulation tracks uncertainty in the outcome. In Proceedings of the 37th Annual Conference of the Cognitive Science Society, 2015.   
+Nicholas Hay, Stuart J. Russell, David Tolpin, and Solomon Eyal Shimony. Selecting computations: Theory and applications. Proceedings of the 28th Conference on Uncertainty in Artificial Intelligence, 2012.   
+Nicolas Heess, Gregory Wayne, David Silver, Tim Lillicrap, Tom Erez, and Yuval Tassa. Learning continuous control policies by stochastic value gradients. Advances in Neural Information Processing Systems, 2015.   
+Mary Hegarty. Mechanical reasoning by mental simulation. Trends in Cognitive Sciences, 8(6):280 – 285, 2004.   
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8):1735–1780, 1997.   
+Matthew W Hoffman, Eric Brochu, and Nando de Freitas. Portfolio allocation for Bayesian optimization. In Proceedings of the 27th Conference on Uncertainty in Artificial Intelligence, pp. 327–336, 2011.   
+Eric J. Horvitz. Reasoning about beliefs and actions under computational resource constraints. In Uncertainty in Artificial Intelligence, Vol. 3, 1988.   
+Philip N Johnson-Laird. Mental models and human reasoning. Proceedings of the National Academy of Sciences, 107(43):18243–18250, 2010.   
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv:1412.6980, 2014.   
+Wouter Kool, Fiery A. Cushman, and Samuel J. Gershman. When does model-based control pay off? PLOS Computational Biology, in press.   
+Sang Wan Lee, Shinsuke Shimojo, and John P. O’Doherty. Neural computations underlying arbitration between model-based and model-free learning. Neuron, 81:687–699, 2014.   
+Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. Journal of Machine Learning Research, 17:1–40, 2016.   
+Falk Lieder and Thomas L. Griffiths. Strategy selection as rational metareasoning. in revision.   
+Falk Lieder, Dillon Plunkett, Jessica B. Hamrick, Stuart J. Russell, Nicholas J. Hay, and Thomas L. Griffiths. Algorithm selection by rational metareasoning as a model of human strategy selection. 27:2870–2878, 2014.   
+Timothy P. Lillicrap, Jonathan J. Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv:1509.02971, 2015.   
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015.   
+Stuart Russell and Eric Wefald. Principles of metareasoning. Artificial Intelligence, 49(1):361 – 395, 1991.   
+Jurgen Schmidhuber. An on-line algorithm for dynamic reinforcement learning and planning in reactive envi-¨ ronments. In Proceedings of the International Joint Conference on Neural Networks (IJCNN), 1990a.   
+Jurgen Schmidhuber. Reinforcement learning in Markovian and non-Markovian environments. ¨ Advances in Neural Information Processing Systems, 1990b.   
+Bobak Shahriari, Ziyu Wang, Matthew W Hoffman, Alexandre Bouchard-Cotˆ e, and Nando de Freitas. An ´ entropy search portfolio for Bayesian optimization. arXiv:1406.4625, 2014.   
+David Silver, Guy Lever, Nicolas Heess, Thomas Degris, Daan Wierstra, and Martin Riedmiller. Deterministic policy gradient algorithms. Proceedings of the 31st International Conference on Machine Learning, 2014.   
+David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of Go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016.   
+Aviv Tamar, Sergey Levine, and Pieter Abbeel. Value Iteration Networks. Advances in Neural Information Processing Systems, 2016. URL http://arxiv.org/abs/1602.02867.   
+Ronald J. Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine Learning, 8(3-4):229–256, 1992.   
+D.M. Wolpert and M. Kawato. Multiple paired forward and inverse models for motor control. Neural Networks, 11(78):1317 – 1329, 1998.
+
+# A METACONTROLLER DETAILS
+
+Here, we give the precise definitions of the metacontroller agent. As described in the main text, the iterative and reactive agents are special cases of the metacontroller agent, and are therefore not discussed here.
+
+The metacontroller agent $a ^ { M }$ is comprised of the following components:
+
+• A history-sensitive controller, $\pi ^ { C } : \mathcal { X } \times \mathcal { X } \times \mathcal { H }  \mathcal { C }$ , which is a policy that maps goal and initial states, and a history, $h \in \mathcal H$ , to controls, whose aim is to minimize (1).   
+• A pool of experts $\{ E _ { 1 } , \ldots , E _ { K } \}$ . Each expert $E : \mathcal { X } \times \mathcal { X } \times \mathcal { C }  \mathcal { E }$ maps goal states, input states, and actions to opinions. Opinions can be either states-only $( { \mathcal { E } } = { \mathcal { X } } $ ), states and rewards ${ \mathcal { E } } =$ $\mathcal { X } \times \mathbb { R } )$ ), or rewards-only $( { \mathcal { E } } = \mathbb { R }$ ). The expert corresponds to the evaluator for the optimization routine, i.e., an approximation of the forward process $f$ .   
+• A manager, $\pi ^ { M } : { \mathcal { X } } \times { \mathcal { X } } \times { \mathcal { H } } _ { n } \to \{ 0 , \dots , K \}$ , which is a policy which decides whether to send a proposed control to the world $k = 0$ ) or to the $k ^ { \mathrm { t h } }$ expert for evaluation, in order to minimize (3). This formulation is based on that used by metareasoning systems (Russell & Wefald, 1991; Hay et al., 2012). Details on the corresponding MDP are given in Appendix A.1.   
+• A memory, $\mu : { \mathcal { H } } _ { n - 1 } \times { \mathcal { Z } } \to { \mathcal { H } } _ { n }$ , which is a function that maps the prior history $h _ { n - 1 } \in \mathcal { H } _ { n - 1 }$ , as well as the most recent manager choice, proposed control, and expert evaluation $( k , c , e ) \in$ $\{ 0 , \dots , K \} \times { \mathcal { C } } \times { \mathcal { E } } = { \mathcal { Z } }$ , to an updated history $\boldsymbol { h _ { n } } ~ \in ~ \mathcal { H } _ { n }$ , which is then made available to the manager and controller on subsequent iterations. The history at step $n$ is a recursively defined tuple which is the concatenation of the prior history with the most recently proposed control, expert evaluation, and expert identity: $h _ { n } \ = \ h _ { n - 1 } \cap \left( \left( k _ { n } , c _ { n } , E _ { k _ { n } } ( x ^ { * } , x , c _ { n } ) \right) \right) \ =$ $( ( k _ { 1 } , c _ { 1 } , E _ { k _ { 1 } } ( x ^ { * } , x , c _ { 1 } ) ) , \ldots , ( k _ { n } , { \bar { c _ { n } } } , E _ { k _ { n } } ( x ^ { * } , x , c _ { n } ) ) )$ ) where $h _ { 0 } = \mathrm { ( ) }$ represents an empty initial history. Similarly, the finite set of histories up to step $n$ is: $\mathcal { H } _ { n } = \mathcal { H } _ { n - 1 } \times \mathcal { Z } = \mathcal { Z } ^ { n }$ where $\mathcal { H } _ { 0 } = \left\{ \left( \begin{array} { l }  \right) \right\} \end{array}$ .
+
+The metacontroller produces:
+
+$$
+a ^ { M } ( x ^ { * } , x ) = \pi ^ { C } ( x ^ { * } , x , h _ { N - 1 } ) = c _ { N }
+$$
+
+where $N = n$ s.t. $k _ { n } = 0$ . This function is summarized in Algorithm 1. The other agents (iterative and reactive), as mentioned in the main text, are simpler versions of the metacontroller agent and are summarized in Algorithms 2 and 3.
+
+# A.1 META-LEVEL MDP
+
+To implement the manager for the metacontroller agent, we draw inspiration from the metareasoning literature (Russell & Wefald, 1991; Hay et al., 2012) and formulate the problem as a finite-horizon Markov Decision Process (MDP) $\langle S , A , P , R \rangle$ over the decision of whether to perform another iteration of the optimization procedure or to execute a control in the world.
+
+• The state space $s$ consists of goal states, external states, and internal histories, $S = \mathcal { X } \times \mathcal { X } \times \mathcal { H }$ . • The action space $\mathcal { A }$ contains $K + 1$ discrete actions, $\{ 0 , \ldots , K \}$ , which correspond to execute $k = 0$ ) and ponder $( k \in \{ 1 , \ldots , K \} )$ , where ponder (after Graves (2016)) refers to performing an iteration of the optimization procedure with the $k ^ { \mathrm { t h } }$ expert.
+
+• The (deterministic) state transition model $P : \mathcal { S } \times \mathcal { C } \times \mathcal { S }  [ 0 , 1 ]$ is,
+
+$$
+P ( x ^ { \prime } , h _ { n } | x ^ { * } , x , h _ { n - 1 } , k ) = { \left\{ \begin{array} { l l } { P ( x ^ { \prime } | x ^ { * } , x , h _ { n - 1 } , k ) } & { { \mathrm { ~ i f ~ } } k = 0 } \\ { P ( h _ { n } | x ^ { * } , x , h _ { n - 1 } , k ) } & { { \mathrm { ~ o t h e r w i s e } } } \end{array} \right. }
+$$
+
+where $x ^ { \prime } = f ( x , c )$ and $c = \pi ^ { C } ( x ^ { * } , x , h _ { n - 1 } )$ and,
+
+$$
+\begin{array} { r l } & { P ( x ^ { \prime } | x ^ { * } , x , h _ { n - 1 } , k ) = \left\{ \begin{array} { l l } { 1 } & { \mathrm { ~ i f ~ } x ^ { \prime } = f ( x , c ) } \\ { 0 } & { \mathrm { ~ o t h e r w i s e } } \end{array} \right. } \\ & { P ( h _ { n } | x ^ { * } , x , h _ { n - 1 } , k ) = \left\{ \begin{array} { l l } { 1 } & { \mathrm { ~ i f ~ } h _ { n } = h _ { n - 1 } \cup \left\{ ( k , c , E _ { k } ( x ^ { * } , x , c ) ) \right\} } \\ { 0 } & { \mathrm { ~ o t h e r w i s e } } \end{array} \right. } \end{array}
+$$
+
+Algorithm 1 Metacontroller agent. $x$ is the scene and $x ^ { * }$ is the target.
+
+<table><tr><td colspan="2">1: function aM(x,x*)</td></tr><tr><td>2: ho←(）,</td><td>Initial empty history</td></tr><tr><td>k0←πM(x,x*,h0） 3:</td><td>Get an action from the manager</td></tr><tr><td>4: C0 ←π℃(x,x*,h)</td><td>&gt;Propose a control with the controller</td></tr><tr><td>5: n←0</td><td></td></tr><tr><td>6: while kn /0 do</td><td>When k ≠ O, ponder with an expert</td></tr><tr><td>7: en←Ekn(x,x*,Cn)</td><td>&gt;Get an expert&#x27;s opinion</td></tr><tr><td>8: hn+1 ←μ(hn,kn,Cn,en)</td><td> Update the history</td></tr><tr><td>9: n↑n+1</td><td></td></tr><tr><td>10: kn←πM(x,x*,hn)</td><td> Choose the next action</td></tr><tr><td>11: Cn ←πC(x,x*,hn)</td><td>&gt;Propose the next control</td></tr><tr><td></td><td></td></tr><tr><td>12: end while</td><td></td></tr><tr><td>13: return Cn</td><td></td></tr><tr><td>14: end function</td><td></td></tr></table>
+
+Algorithm 2 Iterative agent. $x$ is the scene, $x ^ { * }$ is the target, and $N$ is the number of ponder steps.
+
+<table><tr><td colspan="3">1: function a(x,x*, N)</td></tr><tr><td>2:</td><td>ho←()</td><td> Initial empty history</td></tr><tr><td>3:</td><td>C0←π℃(x,x*,h0）</td><td>&gt;Propose a control with the controller</td></tr><tr><td>4:</td><td>n←0</td><td></td></tr><tr><td>5:</td><td>whilen&lt;Ndo</td><td> Ponder with an expert for N steps</td></tr><tr><td>6:</td><td>en←E(x,x*,Cn)</td><td>Get the expert&#x27;s opinion</td></tr><tr><td>7:</td><td>hn+1 ←μ(hn,kn,Cn,en)</td><td>Update the history</td></tr><tr><td>8:</td><td>n←n+1</td><td></td></tr><tr><td>9:</td><td>Cn ←πC(x,x*,hn)</td><td>&gt;Propose the next control</td></tr><tr><td>10:</td><td>end while</td><td></td></tr><tr><td>11:</td><td>return Cn</td><td></td></tr><tr><td colspan="3">12: end function</td></tr><tr><td colspan="3"></td></tr></table>
+
+Algorithm 3 Reactive agent. $x$ is the scene and $x ^ { * }$ is the target.
+
+1: function $a ^ { 0 } ( x , x ^ { * } )$   
+2: c0 ← πC (x, x∗, ())   
+3: return c0   
+4: end function
+
+• The (deterministic) reward function $R : S \times \mathcal { A } \times \mathcal { S }  \mathbb { R }$ maps the current state, current action, and next state to real-valued loss:
+
+$$
+R ( x ^ { * } , x , h _ { n - 1 } , k , x ^ { \prime } ) = { \left\{ \begin{array} { l l } { { \mathcal { L } } ( x ^ { * } , x ^ { \prime } ) } & { { \mathrm { i f ~ } } k = 0 { \mathrm { ~ ( s e e ~ E q . ~ 1 ) ~ } } } \\ { \tau _ { k } } & { { \mathrm { o t h e r w i s e ~ ( s e e ~ E q . ~ 3 ) } } } \end{array} \right. }
+$$
+
+where $x ^ { \prime } = f \left( x , \pi ^ { C } ( x ^ { * } , x , h _ { n - 1 } ) \right)$ .
+
+We approximate the solution to this MDP with a stochastic manager policy $\pi ^ { M }$ . The manager chooses actions proportional to the immediate reward for taking action $k$ in state $s _ { n }$ plus the expected sum of future rewards. This construction imposes a trade-off between accuracy and resources, incentivizing the agent to ponder longer and with more accurate (and potentially expensive) experts when the problem is harder.
+
+![](images/0952d21d580210660011020466fcecf82702d2d7e09413a73e7abcc47f3b1421.jpg)  
+Figure 6: Training each part of the network. In each subplot, red arrows depict gradients. Dotted arrows indicate backward connections that are not part of the forward pass. Colored nodes indicate weights that are being updated. All backpropagation occurs at the very end of a full forward pass (i.e., after the control has been executed in the world). A: Training the controller and memory with backpropagation-through-time (BPTT), beginning with the critic, and flowing to the controller, through the memory, through the relevant expert, through the controller again, and so on. B: Training the manager using REINFORCE (Williams, 1992). C: Training the experts (note that each expert may have a different loss with respect to the outcome from the world). D: Training the critic.
+
+# B GRADIENTS
+
+# B.1 EXPERTS
+
+Training the experts is a straightforward supervised learning problem (Figure 6c). The gradient is:
+
+$$
+\frac { \partial \mathcal { L } ^ { E _ { k } } } { \partial \theta ^ { E _ { k } } } = \frac { \partial \mathcal { L } ^ { E _ { k } } } { \partial E _ { k } } \frac { \partial E _ { k } } { \partial \theta ^ { E _ { k } } } ,
+$$
+
+where $E _ { k }$ is the $k ^ { \mathrm { t h } }$ expert and $\mathcal { L } ^ { E _ { k } }$ is the loss function for the $k ^ { \mathrm { t h } }$ expert. For example, in the case of an action-value function expert, this loss function might be $\mathcal { L } ^ { E _ { k } } ( f , E _ { k } ) \ =$ $\Big | \Big | \mathcal { L } \big ( x ^ { * } , f ( x , c ) \big ) - E _ { k } \big ( x ^ { * } , x , c ; \theta ^ { E _ { k } } \big ) \Big | \Big | _ { 2 }$ . In the case of an expert that predicts the final state using a model of the system dynamics, it might be $\mathcal { L } ^ { E _ { k } } ( f , E _ { k } ) = \left| \left| f ( x , c ) - E _ { k } ( x ^ { * } , x , c ; \theta ^ { E _ { k } } ) \right| \right| _ { 2 }$ .
+
+# B.2 CRITIC
+
+The critic, $\hat { L } _ { P }$ , is an approximate model of the performance loss, $L _ { P }$ , (1), which is used to backpropagate gradients to the controller and memory. This means the critic can either be an action-value function, which approximates $\hat { L } _ { P } = E _ { 0 } \approx L _ { P }$ directly, or a model of the system dynamics composed with a known loss function between the goal and future states, $\hat { L } _ { P } = \mathcal { L } \circ E _ { 0 } \approx \mathcal { L } \circ f .$ . We train the critic, $E _ { 0 } : \mathcal { X } \times \mathcal { X } \times \mathcal { C }  \mathbb { R }$ , using the same procedure as the experts are trained (Figure 6d). A good expert may even be used as the critic.
+
+# B.3 CONTROLLER AND MEMORY
+
+As shown in Figure 6a, we trained the controller and memory using backpropagation through time (BPTT) with an actor-critic architecture. Specifically, rather than assuming $f$ is known and differentiable, we use a critic and backpropagate through it (Heess et al., 2015):
+
+$$
+\frac { \partial \mathcal { L } } { \partial \theta ^ { C } } = \frac { \partial \mathcal { L } } { \partial E _ { * } } \frac { \partial E _ { * } } { \partial \pi _ { n } ^ { C } } \frac { \partial \pi _ { n } ^ { C } } { \partial \mu _ { n } } \frac { \partial ^ { + } \mu _ { n } } { \partial \pi _ { n - 1 } ^ { C } } \cdot \cdot \cdot \frac { \partial \pi _ { 0 } ^ { C } } { \partial \theta ^ { C } } , \quad \quad \frac { \partial \mathcal { L } } { \partial \theta ^ { \mu } } = \frac { \partial \mathcal { L } } { \partial E _ { * } } \frac { \partial E _ { * } } { \partial \pi _ { n } ^ { C } } \frac { \partial \pi _ { n } ^ { C } } { \partial \mu _ { n } } \frac { \partial ^ { + } \mu _ { n } } { \partial \mu _ { n - 1 } } \cdot \cdot \cdot \frac { \partial \mu _ { 0 } } { \partial \theta ^ { \mu } }
+$$
+
+where $E _ { * }$ is the critic, $n$ is the maximum number of iterations the controller can use, and:
+
+$$
+\frac { \partial ^ { + } \mu _ { n } } { \partial \pi _ { n - 1 } ^ { C } } = \frac { \partial \mu _ { n } } { \partial E _ { k _ { n - 1 } } } \frac { \partial E _ { k _ { n - 1 } } } { \partial \pi _ { n - 1 } ^ { C } } + \frac { \partial \mu _ { n } } { \partial \pi _ { n - 1 } ^ { C } } , \quad \quad \quad \quad \frac { \partial ^ { + } \mu _ { n } } { \partial \mu _ { n - 1 } } = \frac { \partial ^ { + } \mu _ { n } } { \partial \pi _ { n - 1 } ^ { C } } + \frac { \partial \mu _ { n } } { \partial \mu _ { n - 1 } }
+$$
+
+where we are using the $\partial ^ { + }$ notation to indicate summed gradients, following Pascanu et al. (2013). Since $k _ { n }$ has already been produced by the manager it can be treated as a constant and will produce an unbiased estimate of the gradient. This is convenient because it allows for training the controller and manager separately, or testing the controller’s behavior with arbitrary actions post-training.
+
+# B.4 MANAGER
+
+As discussed in the main text, we used the REINFORCE algorithm Williams (1992) to train the manager (Figure 6b). One potential issue, however, is that when training the controller and manager simultaneously, the controller will result in high cost early on in training and thus the manager will learn to always choose the execute action. To discourage the manager from learning what is an essentially deterministic policy, we included a regularization term based on the entropy, $L _ { H }$ (Williams & Peng, 1991; Mnih et al., 2016):
+
+$$
+\begin{array} { r l } & { { \cal L } _ { H } ( \cdot ; \theta ^ { M } ) = \lambda \mathbb { E } _ { \pi ^ { M } } [ \log \pi ^ { M } ( \cdot ; \theta ^ { M } ) ] } \\ & { \quad \frac { \partial \mathbb { E } _ { \pi ^ { M } } [ r ] } { \partial \theta ^ { M } } = \left( r - { \cal L } _ { H } ( \cdot ; \theta ^ { M } ) \right) \displaystyle \frac { \partial } { \partial \theta ^ { M } } \log \pi ^ { M } ( \cdot ; \theta ^ { M } ) , } \end{array}
+$$
+
+$r$ is the full return given by (3) and $\lambda$ is the strength of the regularization term.
+
+# C SPACESHIP TASK
+
+# C.1 DATASETS
+
+We generated five datasets, each containing scenes with a different number of planets (ranging from a single planet to five planets). Each dataset consisted of 100,000 training scenes and 1,000 testing scenes. The target in each scene was always located at the origin, and each scene always had a sun with a mass of 100 units. The sun was located between 100 and 200 distance units away from the target, with this distance sampled uniformly at random. The other planets had a mass between 20 and 50 units, and were located 100 to 250 distance units away from the target, sampled uniformly at random. The spaceship had a mass between 1 and 9 units, and was located 150 to 250 distance units away from the target. The planets were always fixed (i.e., they could not move), and the spaceship always started at the beginning of each episode with zero velocity.
+
+# C.2 ENVIRONMENT
+
+We simulated our scenes using a physical simulation of gravitational dynamics. The planets were always stationary (i.e., they were not acted upon by any of the objects in the scene) but acted upon the spaceship with a force of:
+
+$$
+\mathbf { F } _ { p } = G \frac { m _ { p } m _ { s } } { r ^ { 3 } } ( \mathbf { x } _ { p } - \mathbf { x } _ { s } ) ,
+$$
+
+where $\mathbf { F } _ { p }$ is the force vector of the planet on the spaceship, $G = 1 0 0 0 0 0 0$ is a gravitational constant, $m _ { p }$ is the mass of the planet, $m _ { s }$ is the mass of the spaceship, $r$ is the distance between the centers of masses of the planet and the spaceship, $\mathbf { x } _ { p }$ is the location of the planet, and $\mathbf { x } _ { s }$ is the location of the spaceship. We simulated this environment using the Euler method, i.e.:
+
+$$
+\mathbf { a } _ { s } = \frac { ( \sum _ { p } \mathbf { F } _ { p } ) - d \mathbf { v } _ { s } + \mathbf { c } } { m _ { s } } \qquad \mathbf { x } _ { s } ^ { \prime } = \mathbf { x } _ { s } + \epsilon \mathbf { v } _ { s } \qquad \mathbf { v } _ { s } ^ { \prime } = \mathbf { v } _ { s } + \epsilon \mathbf { a } _ { s }
+$$
+
+where $\mathbf { a } _ { s } , \ \mathbf { v } _ { s }$ , and $\mathbf { x } _ { s }$ are the acceleration, velocity, and position of the spaceship, respectively;   
+$d = 0 . 1$ is a damping constant; $\mathbf { c }$ is the control force applied to the spaceship; and $\epsilon$ is the step size.   
+Note that we set c to zero for all timesteps except the first.
+
+# D IMPLEMENTATION DETAILS
+
+We used TensorFlow (Abadi et al., 2015) to implement and train all versions of the model.
+
+# D.1 ARCHITECTURE
+
+In our implementation of the controller, we used a two-layer MLP each with 100 units. The first layer used ReLU activations and the second layer used a multiplicative interaction similar to van den Oord et al. (2016), which we found to work better in practice. In our implementation of the memory, we used a single LSTM layer of size 100. In our implementation of the manager, we used a MLP of two fully connected layers of 100 units each, with ReLU nonlinearities.
+
+We constructed three different experts to test the various controllers. The true simulation expert was the same as the world model, and consisted of a simulation for 11 timesteps with $\epsilon = 0 . 0 5$ (see Appendix C). The IN expert was an interaction network (Battaglia et al., 2016), which has previously been shown to be able to learn to predict $n$ -body dynamics accurately for simple systems. The IN consists of a relational module and an object module. In our case, the relational module was composed of 4 hidden layers of 150 nodes each, outputting “effects” encodings of size 100. These effects, together with the relational model input are then used as input to the object model, which contained a single hidden layer of 100 nodes. The object model outputs the velocity of the spaceship and we trained it to predict the velocity on every timestep of the spaceship’s trajectory. The MLP expert was a MLP that predicted the final location of the spaceship and had the same architecture as the controller.
+
+As discussed in Appendix B, we used a critic to train the controller and memory. We always used the IN expert as the critic, except in the case when the true simulation expert was used, in which case we also used the true simulation as the critic.
+
+# D.2 TRAINING PROCEDURE
+
+All weights were initialized uniformly at random between 0 and 0.01. An iteration of training consisted of gradient updates over a minibatch of size 1000; in total, we ran training for 100,000 iterations. We additionally used a waterfall schedule for each of the learning rates during training, such that after 1000 iterations, if the loss was not decreasing, we would decay the step size by $5 \%$ .
+
+We trained the controller and memory together using the Adam optimizer (Kingma & Ba, 2014) with gradients clipped to a maximum global norm of 10 (Pascanu et al., 2013). The manager was trained simultaneously, but using a different learning rate than the controller and memory. The IN and MLP experts were also trained simultaneously, but again with different learning rates. Learning rates were determined using a grid search over a small number of values, and are given in Table 1 for the iterative agent, in Table 2 for the metacontroller with one expert, and in Table 3 for the metacontroller with two experts.
+
+The iterative agent was trained to take a fixed number of ponder steps, ranging from 0 (i.e., the reactive agent) to 10. The metacontrollers were allowed to take a variable number of ponder steps up to a maximum of 10. For the metacontroller with a single expert, we trained the manager using $\tau = 0$ and 20 additional values of $\tau$ spaced logarithmically between 0.00004 and 0.4 (inclusive). For the metacontroller with multiple experts, we trained the manager on a grid of pairs of $\tau$ values, where each expert could have $\tau = 0$ or one of 6 values spaced logarithmically between 0.00004 and 0.2 (inclusive). In all cases, the entropy penalty for the metacontroller was $\lambda = 0 . 2$ .
+
+# D.3 CONVERGENCE
+
+Reactive agent. Training for the reactive agents was straightforward and converged reliably on all datasets.
+
+Iterative agent. For the iterative agent with the interaction network or true simulation experts, convergence was also reliable for small numbers of ponder steps. Convergence was somewhat less reliable for larger numbers of ponder steps. We believe this is because for some scenes, a larger number of ponder steps was more than necessary to solve the task (as is evidenced by the plateauing performance in Figure 2). So, the iterative agent had to effectively “remember” what the best control was while it took the last few ponder steps, which is a more complicated and difficult task to perform.
+
+For the iterative agent with the MLP expert, convergence was more variable especially when the task was harder, as can be seen in the variable performance on the five planets dataset in Figure 2 (left). We believe this is because the MLP agent was so poor, and that convergence would have been more reliable with a better agent.
+
+Metacontroller with a single expert. The metacontroller agent with a single expert converged more reliably than the corresponding iterative agent (see the bottom row of Figure 3). As mentioned in the previous paragraph, the iterative agent had to take more steps than actually necessary, causing it to perform less well for larger numbers of ponder steps, whereas the metacontroller agent had the flexibility of stopping when it had found a good control. On the other hand, we found that the metacontroller agent sometimes performed too many ponder steps for large values of $\tau$ (see Figures 3 and 7). We believe this is due to the entropy term $( \lambda )$ added to the REINFORCE loss. This is because when then ponder cost is very high, the optimal thing to do is to behave deterministically and always execute (never ponder); however, the entropy term encouraged the policy to be nondeterministic. We plan to explore different training regimes in future work to alleviate this problem, for example by annealing the entropy term to zero over the course of training.
+
+Metacontroller with multiple experts. The metacontroller agent with multiple experts was somewhat more difficult to train, especially for high ponder cost of the interaction network expert. For example, note how the proportion of steps using the MLP expert does not decrease monotonically in Figure 5 (right) with increasing cost for the MLP expert. We believe this is also an unexpected result of using the entropy term: in all of these cases, the optimal thing to do actually is to rely on the MLP expert $100 \%$ of the time, yet the entropy term encourages the policy to be non-deterministic. Future work will explore these difficulties further by using experts that complement each other better (i.e., so there is not one that is wholly better than the other).
+
+Experts. The experts themselves always converged quickly and reliably, and trained much faster than the rest of the network.
+
+# REFERENCES
+
+Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, et al. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015. URL http://tensorflow.org/. Software available from tensorflow.org. Peter Battaglia, Razvan Pascanu, Matthew Lai, Danilo Jimenez Rezende, and Koray Kavukcuoglu. Interaction networks for learning about objects, relations and physics. Advances in Neural Information Processing Systems, 2016. Alex Graves. Adaptive computation time for recurrent neural networks. arXiv:1603.08983, 2016.
+
+Table 1: Hyperparameter values for the iterative controller. $\alpha _ { c }$ refers to the learning rate for the controller and memory, while $\alpha _ { E _ { \mathrm { I N } } }$ refers to the learning rate for the IN expert, and $\alpha _ { E _ { \mathrm { M L P } } }$ refers to the learning rate for the MLP expert.   
+
+<table><tr><td colspan="9">True sim.</td></tr><tr><td colspan="9"></td></tr><tr><td>Dataset</td><td># Ponder Steps</td><td>αc</td><td>αc</td><td>MLP QEIN</td><td>QEMLP</td><td>αc</td><td>IN QEIN</td></tr><tr><td> one planet</td><td>0</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>5e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>one planet</td><td>1</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr><tr><td> one planet</td><td>2</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>5e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td> one planet</td><td>3</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>5e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td> one planet</td><td>4</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr><tr><td> one planet</td><td>5</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>5e-04</td><td>5e-04</td><td>1e-03</td></tr><tr><td> one planet</td><td>6</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>5e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td> one planet</td><td>7</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>5e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td> one planet</td><td>8</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr><tr><td> one planet</td><td>9</td><td>5e-04</td><td>1e-03</td><td>3e-03</td><td>5e-04</td><td>5e-04</td><td>1e-03</td></tr><tr><td>one planet</td><td>10</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>5e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>two planets</td><td>0</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>1e-03</td><td>3e-03</td><td>3e-03</td></tr><tr><td> two planets</td><td>1</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>5e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>two planets</td><td>2</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>5e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td> two planets</td><td>3</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>5e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>two planets</td><td>4</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr><tr><td>two planets</td><td>5</td><td>1e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr><tr><td>two planets</td><td>6</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr><tr><td> two planets</td><td>7</td><td>5e-04</td><td>1e-03</td><td>3e-03</td><td>5e-04</td><td>5e-04</td><td>1e-03</td></tr><tr><td>two planets</td><td>8</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>5e-04</td><td>5e-04</td><td>1e-03</td></tr><tr><td> two planets</td><td>9</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>5e-04</td><td>3e-03</td><td>3e-03</td></tr><tr><td> two planets</td><td>10</td><td>5e-04</td><td>1e-03</td><td>3e-03</td><td>1e-03</td><td>5e-04</td><td>1e-03</td></tr><tr><td> three planets</td><td>0</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>1e-03</td><td>1e-03</td><td>3e-03</td></tr><tr><td>three planets</td><td>1</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr><tr><td>three planets</td><td>2</td><td>1e-03</td><td>5e-04</td><td>3e-03 1e-03</td><td>1e-03 5e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>three planets</td><td>3</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>5e-04</td><td>1e-03 1e-03</td><td>1e-03</td></tr><tr><td> three planets</td><td>4</td><td>1e-03</td><td>1e-03</td><td>1e-03</td><td>5e-04</td><td>5e-04</td><td>1e-03</td></tr><tr><td> three planets</td><td>5 6</td><td>1e-03 1e-03</td><td>1e-03</td><td>3e-03</td><td>5e-04</td><td>1e-03</td><td>1e-03 1e-03</td></tr><tr><td> three planets</td><td>7</td><td></td><td>5e-04</td><td></td><td>1e-03</td><td>1e-03</td><td></td></tr><tr><td> three planets</td><td></td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>1e-03</td><td></td><td>1e-03</td></tr><tr><td>three planets</td><td>8 9</td><td>1e-03 1e-03</td><td>1e-03 1e-03</td><td>3e-03 3e-03</td><td>5e-04</td><td>5e-04 1e-03</td><td>1e-03 1e-03</td></tr><tr><td>three planets</td><td>10</td><td>1e-03</td><td>5e-04</td><td>3e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr><tr><td>three planets</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>four planets</td><td>0</td><td>1e-03</td><td>5e-04</td><td>3e-03</td><td>5e-04 1e-03</td><td>1e-03 1e-03</td><td>1e-03</td></tr><tr><td>four planets</td><td>1</td><td>1e-03 1e-03</td><td>5e-04</td><td>3e-03 3e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03 1e-03</td></tr><tr><td>four planets</td><td>2</td><td>1e-03</td><td>5e-04 1e-03</td><td>3e-03</td><td>5e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>four planets</td><td>3</td><td>1e-03</td><td>5e-04</td><td>3e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr><tr><td>four planets</td><td>4</td><td></td><td></td><td>3e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr><tr><td>four planets</td><td>5</td><td>1e-03</td><td>1e-03</td><td></td><td></td><td></td><td></td></tr><tr><td>four planets</td><td>6</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03 1e-03</td></tr><tr><td>four planets</td><td>7</td><td>5e-04</td><td>1e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03</td><td></td></tr><tr><td>four planets</td><td>8</td><td>5e-04</td><td>1e-03</td><td>3e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr><tr><td>four planets</td><td>9</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>1e-03</td><td>5e-04</td><td>1e-03</td></tr><tr><td>four planets</td><td>10</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>1e-03</td><td>5e-04</td><td>1e-03</td></tr><tr><td>five planets</td><td>0</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>5e-04</td><td>1e-03</td><td>3e-03</td></tr><tr><td>five planets</td><td>1 2</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>5e-04 5e-04</td><td>1e-03</td><td>1e-03 1e-03</td></tr><tr><td>five planets</td><td></td><td>5e-04</td><td>1e-03</td><td>3e-03</td><td></td><td>1e-03</td><td>1e-03</td></tr><tr><td>five planets five planets</td><td>3 4</td><td>1e-03 5e-04</td><td>1e-03 1e-03</td><td>3e-03 3e-03</td><td>1e-03 5e-04</td><td>1e-03 1e-03 1e-03</td></table>
+
+![](images/9fa8aafc246bbddc8609646331910002203334e36a3c5683df7ac519ab172d69.jpg)  
+Figure 7: Cost of the best iterative controller compared to the managed controller. Each point represents the total cost of the best iterative agent under a particular value of $\tau$ $x$ -axis) versus the total cost achieved by the metacontroller trained with the same value of $\tau$ ( $y$ -axis). The best iterative agent was chosen by computing the cost for all the different number of ponder steps, and then choosing the whichever number of ponder stpes yielded the lowest cost (i.e., finding the minimum of the curves in Figure 3, top row). In almost all cases, the managed controller achieves a lower loss than the iterative controller: for the metacontroller with the IN expert, the cost is $11 \%$ lower than the iterative controller on average, and for the metacontroller with the true simulation expert, it is $15 \%$ lower on average.
+
+Nicholas Hay, Stuart J. Russell, David Tolpin, and Solomon Eyal Shimony. Selecting computations: Theory and applications. Proceedings of the 28th Conference on Uncertainty in Artificial Intelligence, 2012.   
+Nicolas Heess, Gregory Wayne, David Silver, Tim Lillicrap, Tom Erez, and Yuval Tassa. Learning continuous control policies by stochastic value gradients. Advances in Neural Information Processing Systems, 2015.   
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv:1412.6980, 2014.   
+Volodymyr Mnih, Adria Puigdom \` enech Badia, Mehdi Mirza, Alex Graves, Timothy P. Lillicrap, Tim Harley, \` David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. Proceedings of the 33rd International Conference on Machine Learning, 2016.   
+Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. Proceedings of the 27st International Conference on Machine Learning, pp. 1310–1318, 2013.   
+Stuart Russell and Eric Wefald. Principles of metareasoning. Artificial Intelligence, 49(1):361 – 395, 1991.   
+Aaron van den Oord, Nal Kalchbrenner, Oriol Vinyals, Lasse Espeholt, Alex Graves, and Koray Kavukcuoglu. ¨ Conditional image generation with PixelCNN decoders. arXiv:1606.05328, 2016.   
+Ronald J. Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine Learning, 8(3-4):229–256, 1992.   
+Ronald J. Williams and Jing Peng. Function optimization using connectionist reinforcement learning algorithms. Connection Science, 3(3):241–268, 1991.
+
+<table><tr><td></td><td colspan="2">True sim.</td><td colspan="4">MLP</td><td colspan="3">IN</td></tr><tr><td>T</td><td>αc</td><td>αm</td><td>αc</td><td>αm</td><td>QEIN</td><td>QEMLP</td><td>αc</td><td>αm</td><td>QEIN</td></tr><tr><td>0.00000</td><td>5e-04</td><td>5e-04</td><td>5e-04</td><td>1e-03</td><td>3e-03</td><td>1e-03</td><td>5e-04</td><td>1e-04</td><td>1e-03</td></tr><tr><td>0.00004</td><td>1e-03</td><td>1e-04</td><td>1e-03</td><td>5e-05</td><td>3e-03</td><td>5e-04</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.00006</td><td>5e-04</td><td>5e-05</td><td>1e-03</td><td>5e-04</td><td>3e-03</td><td>1e-03</td><td>5e-04</td><td>5e-05</td><td>1e-03</td></tr><tr><td>0.00011</td><td>1e-03</td><td>1e-04</td><td>1e-03</td><td>1e-04</td><td>3e-03</td><td>1e-03</td><td>5e-04</td><td>5e-04</td><td>1e-03</td></tr><tr><td>0.00017</td><td>5e-04</td><td>1e-04</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>1e-03</td><td>1e-03</td><td>5e-05</td><td>1e-03</td></tr><tr><td>0.00028</td><td>1e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>1e-03</td><td>5e-04</td><td>5e-05</td><td>1e-03</td></tr><tr><td>0.00045</td><td>1e-03</td><td>1e-03</td><td>5e-04</td><td>1e-04</td><td>3e-03</td><td>1e-03</td><td>1e-03</td><td>5e-05</td><td>1e-03</td></tr><tr><td>0.00073</td><td>1e-03</td><td>1e-04</td><td>1e-03</td><td>1e-04</td><td>3e-03</td><td>1e-03</td><td>1e-03</td><td>5e-05</td><td>1e-03</td></tr><tr><td>0.00119</td><td>1e-03</td><td>5e-05</td><td>1e-03</td><td>1e-04</td><td>5e-04</td><td>1e-03</td><td>5e-04</td><td>5e-04</td><td>1e-03</td></tr><tr><td>0.00193</td><td>1e-03</td><td>5e-05</td><td>1e-03</td><td>5e-05</td><td>3e-03</td><td>5e-04</td><td>1e-03</td><td>5e-05</td><td>1e-03</td></tr><tr><td>0.00314</td><td>1e-03</td><td>1e-04</td><td>1e-03</td><td>1e-04</td><td>3e-03</td><td>5e-04</td><td>1e-03</td><td>1e-04</td><td>1e-03</td></tr><tr><td>0.00510</td><td>1e-03</td><td>5e-05</td><td>1e-03</td><td>5e-05</td><td>3e-03</td><td>1e-03</td><td>1e-03</td><td>5e-05</td><td>1e-03</td></tr><tr><td>0.00828</td><td>1e-03</td><td>5e-04</td><td>1e-03</td><td>5e-04</td><td>3e-03</td><td>5e-04</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.01344</td><td>1e-03</td><td>5e-05</td><td>1e-03</td><td>5e-05</td><td>3e-03</td><td>5e-04</td><td>5e-04</td><td>5e-05</td><td>1e-03</td></tr><tr><td>0.02182</td><td>1e-03</td><td>1e-04</td><td>1e-03</td><td>1e-04</td><td>3e-03</td><td>5e-04</td><td>1e-03</td><td>1e-04</td><td>1e-03</td></tr><tr><td>0.03543</td><td>1e-03</td><td>1e-04</td><td>1e-03</td><td>1e-04</td><td>3e-03</td><td>1e-03</td><td>1e-03</td><td>1e-04</td><td>1e-03</td></tr><tr><td>0.05754</td><td>1e-03</td><td>5e-04</td><td>1e-03</td><td>5e-04</td><td>3e-03</td><td>5e-04</td><td>1e-03</td><td>1e-04</td><td>1e-03</td></tr><tr><td>0.09343</td><td>1e-03</td><td>5e-05</td><td>1e-03</td><td>5e-05</td><td>3e-03</td><td>1e-03</td><td>1e-03</td><td>1e-04</td><td>1e-03</td></tr><tr><td>0.15171</td><td>1e-03</td><td>1e-04</td><td>1e-03</td><td>5e-04</td><td>3e-03</td><td>5e-04</td><td>1e-03</td><td>1e-04</td><td>1e-03</td></tr><tr><td>0.24634</td><td>1e-03</td><td>5e-05</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.40000</td><td>1e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03</td><td>3e-03</td><td>5e-04</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr></table>
+
+Table 2: Hyperparameter values for the metacontroller with a single expert. $\tau$ refers to the ponder cost, $\alpha _ { c }$ refers to the learning rate for the controller and memory, $\alpha _ { m }$ refers to the learning rate for the manager, $\alpha _ { E _ { \mathrm { I N } } }$ refers to the learning rate for the IN expert, and $\alpha _ { E _ { \mathrm { M L P } } }$ refers to the learning rate for the MLP expert.
+
+Table 3: Hyperparameter values for the metacontroller with two experts. $\tau _ { \mathrm { I N } }$ refers to the ponder cost for the interaction network expert, $\tau _ { \mathrm { M L P } }$ refers to the ponder cost for the MLP expert, $\alpha _ { c }$ refers to the learning rate for the controller and memory, $\alpha _ { m }$ refers to the learning rate for the manager, $\alpha _ { E _ { \mathrm { I N } } }$ refers to the learning rate for the IN expert, and $\alpha _ { E _ { \mathrm { M L P } } }$ refers to the learning rate for the MLP expert.   
+
+<table><tr><td colspan="2"></td><td colspan="4">IN + MLP</td></tr><tr><td>TIN</td><td>TMLP</td><td>αc</td><td>am</td><td>QEIN</td><td>QEMLP</td></tr><tr><td>0.00000</td><td>0.00000</td><td>1e-03</td><td>5e-05</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.00000</td><td>0.00121</td><td>1e-03</td><td>5e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.00000</td><td>0.00663</td><td>1e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.00000</td><td>0.03641</td><td>1e-03</td><td>5e-05</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.00000</td><td>0.20000</td><td>1e-03</td><td>5e-05</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.00000</td><td>0.30000</td><td>5e-04</td><td>1e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.00000</td><td>0.40000</td><td>5e-04</td><td>5e-05</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.00121</td><td>0.00000</td><td>1e-03</td><td>1e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.00121</td><td>0.00121</td><td>1e-03</td><td>5e-05</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.00121</td><td>0.00663</td><td>1e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.00121</td><td>0.03641</td><td>1e-03</td><td>1e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.00121</td><td>0.20000</td><td>1e-03</td><td>5e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.00121</td><td>0.30000</td><td>5e-04</td><td>5e-05</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.00121</td><td>0.40000</td><td>1e-03</td><td>1e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.00663</td><td>0.00000</td><td>1e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.00663</td><td>0.00121</td><td>5e-04</td><td>5e-05</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.00663</td><td>0.00663</td><td>5e-04</td><td>1e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.00663</td><td>0.03641</td><td>1e-03</td><td>1e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.00663</td><td>0.20000</td><td>5e-04</td><td>5e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.00663</td><td>0.30000</td><td>5e-04</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.00663</td><td>0.40000</td><td>5e-04</td><td>1e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.03641</td><td>0.00000</td><td>1e-03</td><td>5e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.03641</td><td>0.00121</td><td>1e-03</td><td>5e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.03641</td><td>0.00663</td><td>1e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.03641</td><td>0.03641</td><td>1e-03</td><td>5e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.03641</td><td>0.20000</td><td>1e-03</td><td>1e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.03641</td><td>0.30000</td><td>1e-03</td><td>5e-05</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.03641</td><td>0.40000</td><td>1e-03</td><td>1e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.20000</td><td>0.00000</td><td>1e-03</td><td>5e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.20000</td><td>0.00121</td><td>1e-03</td><td>5e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.20000</td><td>0.00663</td><td>1e-03</td><td>5e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.20000</td><td>0.03641</td><td>1e-03</td><td>1e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.20000</td><td>0.20000</td><td>5e-04</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.20000</td><td>0.30000</td><td>1e-03</td><td>5e-05</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.20000</td><td>0.40000</td><td>1e-03</td><td>5e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.30000</td><td>0.00000</td><td>5e-04</td><td>1e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.30000</td><td>0.00121</td><td>5e-04</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.30000</td><td>0.00663</td><td>1e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.30000</td><td>0.03641</td><td>1e-03</td><td>5e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.30000</td><td>0.20000</td><td>1e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.30000</td><td>0.30000</td><td>1e-03</td><td>1e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.30000</td><td>0.40000</td><td>1e-03</td><td>5e-05</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.40000</td><td>0.00000</td><td>1e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.40000</td><td>0.00121</td><td>5e-04</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.40000</td><td>0.00663</td><td>1e-03</td><td>5e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.40000</td><td>0.03641</td><td>5e-04</td><td>1e-04</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.40000</td><td>0.20000</td><td>1e-03</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.40000</td><td>0.30000</td><td>5e-04</td><td>1e-03</td><td>1e-03</td><td>1e-03</td></tr><tr><td>0.40000</td><td>0.40000</td><td>5e-04</td><td>5e-04</td><td>1e-03</td><td>1e-03</td></tr></table>

parse/train/BkJ3ibb0-/BkJ3ibb0-.md

@@ -0,0 +1,382 @@
+# DEFENSE-GAN: PROTECTING CLASSIFIERSAGAINST ADVERSARIAL ATTACKS USINGGENERATIVE MODELS
+
+Pouya Samangouei∗, Maya Kabkab∗, and Rama Chellappa
+
+Department of Electrical and Computer Engineering University of Maryland Institute for Advanced Computer Studies University of Maryland, College Park, MD 20742 {pouya, mayak, rama}@umiacs.umd.edu
+
+# ABSTRACT
+
+In recent years, deep neural network approaches have been widely adopted for machine learning tasks, including classification. However, they were shown to be vulnerable to adversarial perturbations: carefully crafted small perturbations can cause misclassification of legitimate images. We propose Defense-GAN, a new framework leveraging the expressive capability of generative models to defend deep neural networks against such attacks. Defense-GAN is trained to model the distribution of unperturbed images. At inference time, it finds a close output to a given image which does not contain the adversarial changes. This output is then fed to the classifier. Our proposed method can be used with any classification model and does not modify the classifier structure or training procedure. It can also be used as a defense against any attack as it does not assume knowledge of the process for generating the adversarial examples. We empirically show that Defense-GAN is consistently effective against different attack methods and improves on existing defense strategies.
+
+# 1 INTRODUCTION
+
+Despite their outstanding performance on several machine learning tasks, deep neural networks have been shown to be susceptible to adversarial attacks (Szegedy et al., 2014; Goodfellow et al., 2015). These attacks come in the form of adversarial examples: carefully crafted perturbations added to a legitimate input sample. In the context of classification, these perturbations cause the legitimate sample to be misclassified at inference time (Szegedy et al., 2014; Goodfellow et al., 2015; Papernot et al., 2016b; Liu et al., 2017). Such perturbations are often small in magnitude and do not affect human recognition but can drastically change the output of the classifier.
+
+Recent literature has considered two types of threat models: black-box and white-box attacks. Under the black-box attack model, the attacker does not have access to the classification model parameters; whereas in the white-box attack model, the attacker has complete access to the model architecture and parameters, including potential defense mechanisms (Papernot et al., 2017; Tramer et al., 2017; \` Carlini & Wagner, 2017).
+
+Various defenses have been proposed to mitigate the effect of adversarial attacks. These defenses can be grouped under three different approaches: (1) modifying the training data to make the classifier more robust against attacks, e.g., adversarial training which augments the training data of the classifier with adversarial examples (Szegedy et al., 2014; Goodfellow et al., 2015), (2) modifying the training procedure of the classifier to reduce the magnitude of gradients, e.g., defensive distillation (Papernot et al., 2016d), and (3) attempting to remove the adversarial noise from the input samples (Hendrycks & Gimpel, 2017; Meng & Chen, 2017). All of these approaches have limitations in the sense that they are effective against either white-box attacks or black-box attacks, but not both (Tramer et al., 2017; Meng & Chen, 2017). Furthermore, some of these defenses are devised \` with specific attack models in mind and are not effective against new attacks.
+
+In this paper, we propose a novel defense mechanism which is effective against both white-box and black-box attacks. We propose to leverage the representative power of Generative Adversarial Networks (GAN) (Goodfellow et al., 2014) to diminish the effect of the adversarial perturbation, by “projecting” input images onto the range of the GAN’s generator prior to feeding them to the classifier. In the GAN framework, two models are trained simultaneously in an adversarial setting: a generative model that emulates the data distribution, and a discriminative model that predicts whether a certain input came from real data or was artificially created. The generative model learns a mapping $G$ from a low-dimensional vector $\mathbf { z } \in \mathbb { R } ^ { k }$ to the high-dimensional input sample space $\mathbb { R } ^ { n }$ . During training of the GAN, $G$ is encouraged to generate samples which resemble the training data. It is, therefore, expected that legitimate samples will be close to some point in the range of $G$ , whereas adversarial samples will be further away from the range of $G$ . Furthermore, “projecting” the adversarial examples onto the range of the generator $G$ can have the desirable effect of reducing the adversarial perturbation. The projected output, computed using Gradient Descent (GD), is fed into the classifier instead of the original (potentially adversarially modified) image. We empirically demonstrate that this is an effective defense against both black-box and white-box attacks on two benchmark image datasets.
+
+The rest of the paper is organized as follows. We introduce the necessary background regarding known attack models, defense mechanisms, and GANs in Section 2. Our defense mechanism, which we call Defense-GAN, is formally motivated and introduced in Section 3. Finally, experimental results, under different threat models, as well as comparisons to other defenses are presented in Section 4.
+
+# 2 RELATED WORK AND BACKGROUND INFORMATION
+
+In this work, we propose to use GANs for the purpose of defending against adversarial attacks in classification problems. Before detailing our approach in the next section, we explain related work in three parts. First, we discuss different attack models employed in the literature. We, then, go over related defense mechanisms against these attacks and discuss their strengths and shortcomings. Lastly, we explain necessary background information regarding GANs.
+
+# 2.1 ATTACK MODELS AND ALGORITHMS
+
+Various attack models and algorithms have been used to target classifiers. All attack models we consider aim to find a perturbation $\delta$ to be added to a (legitimate) input $\mathbf { x } \in \mathbb { R } ^ { n }$ , resulting in the adversarial example $\tilde { \mathbf { x } } = \mathbf { x } + \delta$ . The $\ell _ { \infty }$ -norm of the perturbation is denoted by $\epsilon$ (Goodfellow et al., 2015) and is chosen to be small enough so as to remain undetectable. We consider two threat levels: black- and white-box attacks.
+
+# 2.1.1 WHITE-BOX ATTACK MODELS
+
+White-box models assume that the attacker has complete knowledge of all the classifier parameters, i.e., network architecture and weights, as well as the details of any defense mechanism. Given an input image $\mathbf { x }$ and its associated ground-truth label $y$ , the attacker thus has access to the loss function $J ( \mathbf { x } , y )$ used to train the network, and uses it to compute the adversarial perturbation $\pmb { \delta }$ . Attacks can be targeted, in that they attempt to cause the perturbed image to be misclassified to a specific target class, or untargeted when no target class is specified.
+
+In this work, we focus on untargeted white-box attacks computed using the Fast Gradient Sign Method (FGSM) (Goodfellow et al., 2015), the Randomized Fast Gradient Sign Method (RAND $+$ FGSM) (Tramer et al., 2017), and the Carlini-Wagner (CW) attack (Carlini & Wagner, \` 2017). Although other attack models exist, such as the Iterative FGSM (Kurakin et al., 2017), the Jacobian-based Saliency Map Attack (JSMA) (Papernot et al., 2016b), and Deepfool (MoosaviDezfooli et al., 2016), we focus on these three models as they cover a good breadth of attack algorthims. FGSM is a very simple and fast attack algorithm which makes it extremely amenable to real-time attack deployment. On the other hand, RAND+FGSM, an equally simple attack, increases the power of FGSM for white-box attacks (Tramer et al., 2017), and finally, the CW attack is one of \` the most powerful white-box attacks to-date (Carlini & Wagner, 2017).
+
+Fast Gradient Sign Method (FGSM) Given an image $\mathbf { x }$ and its corresponding true label $y$ , the FGSM attack sets the perturbation $\pmb { \delta }$ to:
+
+$$
+\pmb { \delta } = \epsilon \cdot \mathrm { s i g n } ( \nabla _ { \mathbf { x } } J ( \mathbf { x } , y ) ) .
+$$
+
+FGSM (Goodfellow et al., 2015) was designed to be extremely fast rather than optimal. It simply uses the sign of the gradient at every pixel to determine the direction with which to change the corresponding pixel value.
+
+Randomized Fast Gradient Sign Method (RAND+FGSM) The RAND $^ +$ FGSM (Tramer et al., \` 2017) attack is a simple yet effective method to increase the power of FGSM against models which were adversarially trained. The idea is to first apply a small random perturbation before using FGSM. More explicitly, for $\alpha < \epsilon$ , random noise is first added to the legitimate image x:
+
+$$
+\mathbf { x } ^ { \prime } = \mathbf { x } + { \boldsymbol { \alpha } } \cdot \mathrm { s i g n } ( { \mathcal { N } } ( \mathbf { 0 } ^ { n } , \mathbf { I } ^ { n } ) ) .
+$$
+
+Then, the FGSM attack is computed on $\mathbf { x } ^ { \prime }$ , resulting in
+
+$$
+\tilde { \mathbf { x } } = \mathbf { x } ^ { \prime } + ( \epsilon - \alpha ) \cdot \mathrm { s i g n } \big ( \nabla _ { \mathbf { x } ^ { \prime } } J ( \mathbf { x } ^ { \prime } , y ) \big ) .
+$$
+
+The Carlini-Wagner (CW) attack The CW attack is an effective optimization-based attack model (Carlini & Wagner, 2017). In many cases, it can reduce the classifier accuracy to almost $0 \%$ (Carlini & Wagner, 2017; Meng & Chen, 2017). The perturbation $\pmb { \delta }$ is found by solving an optimization problem of the form:
+
+$$
+\begin{array} { r l } { \underset { \delta \in \mathbb { R } ^ { n } } { \operatorname* { m i n } } } & { \quad | | \pmb { \delta } | | _ { p } + c \cdot f ( \mathbf { x } + \pmb { \delta } ) } \\ { \mathrm { s . t . } } & { \quad \mathbf { x } + \pmb { \delta } \in [ 0 , 1 ] ^ { n } , } \end{array}
+$$
+
+where $f$ is an objective function that drives the example $\mathbf { x }$ to be misclassified, and $c > 0$ is a suitably chosen constant. The $\ell _ { 2 } , \ell _ { 0 }$ , and $\ell _ { \infty }$ norms are considered. We refer the reader to (Carlini & Wagner, 2017) for details regarding the approach to solving (4) and setting the constant $c$ .
+
+# 2.1.2 BLACK-BOX ATTACK MODELS
+
+For black-box attacks we consider untargeted FGSM attacks computed on a substitute model (Papernot et al., 2017). As previously mentioned, black-box adversaries have no access to the classifier or defense parameters. It is further assumed that they do not have access to a large training dataset but can query the targeted DNN as a black-box, i.e., access labels produced by the classifier for specific query images. The adversary trains a model, called substitute, which has a (potentially) different architecture than the targeted classifier, using a very small dataset augmented by synthetic images labeled by querying the classifier. Adversarial examples are then found by applying any attack method on the substitute network. It was found that such examples designed to fool the substitute often end up being misclassified by the targeted classifier (Szegedy et al., 2014; Papernot et al., 2017). In other words, black-box attacks are easily transferrable from one model to the other.
+
+# 2.2 DEFENSE MECHANISMS
+
+Various defense mechanisms have been employed to combat the threat from adversarial attacks. In what follows, we describe one representative defense strategy from each of the three general groups of defenses.
+
+# 2.2.1 ADVERSARIAL TRAINING
+
+A popular approach to defend against adversarial noise is to augment the training dataset with adversarial examples (Szegedy et al., 2014; Goodfellow et al., 2015; Moosavi-Dezfooli et al., 2016). Adversarial examples are generated using one or more chosen attack models and added to the training set. This often results in increased robustness when the attack model used to generate the augmented training set is the same as that used by the attacker. However, adversarial training does not perform as well when a different attack strategy is used by the attacker. Additionally, it tends to make the model more robust to white-box attacks than to black-box attacks due to gradient masking (Papernot et al., 2016c; 2017; Tramer et al., 2017). \`
+
+# 2.2.2 DEFENSIVE DISTILLATION
+
+Defensive distillation (Papernot et al., 2016d) trains the classifier in two rounds using a variant of the distillation (Hinton et al., 2014) method. This has the desirable effect of learning a smoother network and reducing the amplitude of gradients around input points, making it difficult for attackers to generate adversarial examples (Papernot et al., 2016d). It was, however, shown that, while defensive distillation is effective against white-box attacks, it fails to adequately protect against black-box attacks transferred from other networks (Carlini & Wagner, 2017).
+
+# 2.2.3 MAGNET
+
+Recently, Meng & Chen (2017) introduced MagNet as an effective defense strategy. It trains a reformer network (which is an auto-encoder or a collection of auto-encoders) to move adversarial examples closer to the manifold of legitimate, or natural, examples. When using a collection of auto-encoders, one reformer network is chosen at random at test time, thus strengthening the defense. It was shown to be an effective defense against gray-box attacks where the attacker knows everything about the network and defense, except the parameters. MagNet is the closest defense to our approach, as it attempts to reform an adversarial sample using a learnt auto-encoder. The main differences between MagNet and our approach are: (1) we use GANs instead of auto-encoders, and, most importantly, (2) we use GD minimization to find latent codes as opposed to a feedforward encoder network. This makes Defense-GAN more robust, especially against white-box attacks.
+
+# 2.3 GENERATIVE ADVERSARIAL NETWORKS (GANS)
+
+GANs, originally introduced by Goodfellow et al. (2014), consist of two neural networks, $G$ and $D . G : \mathbb { R } ^ { k }  \mathbb { R } ^ { n }$ maps a low-dimensional latent space to the high dimensional sample space of $\mathbf { x }$ . $D$ is a binary neural network classifier. In the training phase, $G$ and $D$ are typically learned in an adversarial fashion using actual input data samples $\mathbf { x }$ and random vectors $\mathbf { z }$ . An isotropic Gaussian prior is usually assumed on $\mathbf { z }$ . While $G$ learns to generate outputs $G ( \mathbf { z } )$ that have a distribution similar to that of $\mathbf { x }$ , $D$ learns to discriminate between “real” samples $\mathbf { x }$ and “fake” samples $G ( \mathbf { z } )$ . $D$ and $G$ are trained in an alternating fashion to minimize the following min-max loss (Goodfellow et al., 2014):
+
+$$
+\displaystyle \operatorname* { m i n } _ { G } \operatorname* { m a x } _ { D } V ( D , G ) = \mathbb { E } _ { \mathbf { x } \sim p _ { \mathrm { d a t a } } ( \mathbf { x } ) } [ \log D ( \mathbf { x } ) ] + \mathbb { E } _ { \mathbf { z } \sim p _ { \mathbf { z } } ( \mathbf { z } ) } [ \log ( 1 - D ( G ( \mathbf { z } ) ) ) ] .
+$$
+
+It was shown that the optimal GAN is obtained when the resulting generator distribution $p _ { g } = p _ { \mathrm { d a t a } }$ (Goodfellow et al., 2014).
+
+However, GANs turned out to be difficult to train in practice (Gulrajani et al., 2017), and alternative formulations have been proposed. Arjovsky et al. (2017) introduced Wasserstein GANs (WGANs) which are a variant of GANs that use the Wasserstein distance, resulting in a loss function with more desirable properties:
+
+$$
+\operatorname* { m i n } _ { G } \operatorname* { m a x } _ { D } V _ { W } ( D , G ) = \mathbb { E } _ { { \mathbf { x } } \sim p _ { \mathrm { d a t a } } ( { \mathbf { x } } ) } [ D ( { \mathbf { x } } ) ] - \mathbb { E } _ { { \mathbf { z } } \sim p _ { \mathbf { z } } ( { \mathbf { z } } ) } [ D ( G ( { \mathbf { z } } ) ) ] .
+$$
+
+In this work, we use WGANs as our generative model due to the stability of their training methods, especially using the approach in (Gulrajani et al., 2017).
+
+# 3 PROPOSED DEFENSE-GAN
+
+We propose a new defense strategy which uses a WGAN trained on legitimate (un-perturbed) training samples to “denoise” adversarial examples. At test time, prior to feeding an image $\mathbf { x }$ to the classifier, we project it onto the range of the generator by minimizing the reconstruction error $| | G ( \mathbf { z } ) - \mathbf { x } | | _ { 2 } ^ { 2 }$ , using $L$ steps of GD. The resulting reconstruction $G ( \mathbf { z } )$ is then given to the classifier. Since the generator was trained to model the unperturbed training data distribution, we expect this added step to result in a substantial reduction of any potential adversarial noise. We formally motivate this approach in the following section.
+
+![](images/1fae85dead9d7121c6a0e870142d4b0e7fadb38d6743581d8ce158b74f66b71b.jpg)  
+Figure 1: Overview of the Defense-GAN algorithm.
+
+# 3.1 MOTIVATION
+
+As mentioned in Section 2.3, the GAN min-max loss in (5) admits a global optimum when $p _ { g } = p _ { \mathrm { d a t a } }$ (Goodfellow et al., 2014). It can be similarly shown that WGAN admits an optimum to its own minmax loss in (6), when the set $\{ \mathbf { x } \mid p _ { g } ( \mathbf { x } ) \neq { \overline { { p _ { \mathrm { d a t a } } ( \mathbf { x } ) } } } \}$ has zero Lebesgue-measure. Formally,
+
+Lemma 1 A generator distribution $p _ { g }$ is a global optimum for the WGAN min-max game defined in (6), if and only $i f p _ { g } ( \mathbf { x } ) = p _ { d a t a } ( \mathbf { x } ) \dot { }$ for all $\mathbf { x } \in \mathbb { R } ^ { n }$ , potentially except on a set of zero Lebesguemeasure.
+
+A sketch of the proof can be found in Appendix A.
+
+Additionally, it was shown that, if $G$ and $D$ have enough capacity to represent the data, and if the training algorithm is such that $p _ { g }$ converges to $p _ { \mathrm { d a t a } }$ , then
+
+$$
+\mathbb { E } _ { \mathbf { x } \sim p _ { \mathrm { d a t a } } } \left[ \operatorname* { m i n } _ { \mathbf { z } } | | G _ { t } ( \mathbf { z } ) - \mathbf { x } | | _ { 2 } \right] \longrightarrow 0
+$$
+
+where $G _ { t }$ is the generator of a GAN or $\mathbf { W G A N ^ { 1 } }$ after $t$ steps of its training algorithm (Kabkab et al., 2018).
+
+This serves to show that, under ideal conditions, the addition of the GAN reconstruction loss minimization step should not affect the performance of the classifier on natural, legitimate samples, as such samples should be almost exactly recovered. Furthermore, we hypothesize that this step will help reduce the adversarial noise which follows a different distribution than that of the GAN training examples.
+
+# 3.2 DEFENSE-GAN ALGORITHM
+
+Defense-GAN is a defense strategy to combat both white-box and black-box adversarial attacks against classification networks. At inference time, given a trained GAN generator $G$ and an image $\mathbf { x }$ to be classified, $\mathbf { z } ^ { \ast }$ is first found so as to minimize
+
+$$
+\operatorname* { m i n } _ { \mathbf { z } } | | G ( \mathbf { z } ) - \mathbf { x } | | _ { 2 } ^ { 2 } .
+$$
+
+$G ( \mathbf { z } ^ { * } )$ is then given as the input to the classifier. The algorithm is illustrated in Figure 1. As (8) is a highly non-convex minimization problem, we approximate it by doing a fixed number $L$ of GD steps using $R$ different random initializations of $\mathbf { z }$ (which we call random restarts), as shown in Figures 1 and 2.
+
+The GAN is trained on the available classifier training dataset in an unsupervised manner. The classifier can be trained on the original training images, their reconstructions using the generator $G$ , or a combination of the two. As was discussed in Section 3.1, as long as the GAN is appropriately trained and has enough capacity to represent the data, original clean images and their reconstructions should not defer much. Therefore, these two classifier training strategies should, at least theoretically, not differ in performance.
+
+Compared to existing defense mechanisms, our approach is different in the following aspects:
+
+![](images/ba7bf83a9b6fd05891a79983aae8bdfecddb39ee7439c103667c4aceec0a82d2.jpg)  
+Figure 2: $L$ steps of Gradient Descent are used to estimate the projection of the image onto the range of the generator.
+
+1. Defense-GAN can be used in conjunction with any classifier and does not modify the classifier structure itself. It can be seen as an add-on or pre-processing step prior to classification. 2. If the GAN is representative enough, re-training the classifier should not be necessary and any drop in performance due to the addition of Defense-GAN should not be significant. 3. Defense-GAN can be used as a defense to any attack: it does not assume an attack model, but simply leverages the generative power of GANs to reconstruct adversarial examples. 4. Defense-GAN is highly non-linear and white-box gradient-based attacks will be difficult to perform due to the GD loop. A detailed discussion about this can be found in Appendix B.
+
+# 4 EXPERIMENTS
+
+We assume three different attack threat levels:
+
+1. Black-box attacks: the attacker does not have access to the details of the classifier and defense strategy. It therefore trains a substitute network to find adversarial examples.   
+2. White-box attacks: the attacker knows all the details of the classifier and defense strategy. It can compute gradients on the classifier and defense networks in order to find adversarial examples.   
+3. White-box attacks, revisited: in addition to the details of the architectures and parameters of the classifier and defense, the attacker has access to the random seed and random number generator. In the case of Defense-GAN, this means that the attacker knows all the random initializations { z 0 } Ri =1 .
+
+We compare our method to adversarial training (Goodfellow et al., 2015) and MagNet (Meng & Chen, 2017) under the FGSM, RAND $^ +$ FGSM, and CW (with $\ell _ { 2 }$ norm) white-box attacks, as well as the FGSM black-box attack. Details of all network architectures used in this paper can be found in Appendix C. When the classifier is trained using the reconstructed images $( G ( \mathbf { z } ^ { * } ) )$ , we refer to our method as Defense-GAN-Rec, and we use Defense-GAN-Orig when the original images $\mathbf { \tau } ( \mathbf { x } )$ are used to train the classifier. Our GAN follows the WGAN training procedure in (Gulrajani et al., 2017), and details of the generator and discriminator network architectures are given in Table 6. The reformer network (encoder) for the MagNet baseline is provided in Table 7. Our implementation is based on TensorFlow (Abadi et al., 2015) and builds on open-source software: CleverHans by Papernot et al. (2016a) and improved WGAN training by Gulrajani et al. (2017). We use machines equipped with NVIDIA GeForce GTX TITAN X GPUs.
+
+In our experiments, we use two different image datasets: the MNIST handwritten digits dataset (LeCun et al., 1998) and the Fashion-MNIST (F-MNIST) clothing articles dataset (Xiao et al., 2017). Both datasets consist of 60, 000 training images and $1 0 , 0 0 0$ testing images. We split the training images into a training set of 50, 000 images and hold-out a validation set containing 10, 000 images. For white-box attacks, the testing set is kept the same (10, 000 samples). For black-box attacks, the testing set is divided into a small hold-out set of 150 samples reserved for adversary substitute training, as was done in (Papernot et al., 2017), and the remaining 9, 850 samples are used for testing the different methods.
+
+# 4.1 RESULTS ON BLACK-BOX ATTACKS
+
+In this section, we present experimental results on FGSM black-box attacks. As previously mentioned, the attacker trains a substitute model, which could differ in architecture from the targeted model, using a limited dataset consisting of 150 legitimate images augmented with synthetic images labeled using the target classifier. The classifier and substitute model architectures used and referred to throughout this section are described in Table 5 in the Appendix.
+
+In Tables 1 and 2, we present our classification accuracy results and compare to other defense methods. As can be seen, FGSM black-box attacks were successful at reducing the classifier accuracy by up to $7 0 \%$ . All considered defense mechanisms are relatively successful at diminishing the effect of the attacks. We note that, as expected, the performance of Defense-GAN-Rec and that of Defense-GAN-Orig are very close. In addition, they both perform consistently well across different classifier and substitute model combinations. MagNet also performs in a consistent manner, but achieves lower accuracy than Defense-GAN. Two adversarial training defenses are presented: the first one obtains the adversarial examples assuming the same attack $\epsilon = 0 . 3$ , and the second assumes a different $\epsilon = 0 . 1 5$ . With incorrect knowledge of $\epsilon$ , the performance of adversarial training generally decreases. In addition, the classification performance of this defense method has very large variance across the different architectures. It is worth noting that adversarial training defense is only fit against FGSM attacks, because the adversarially augmented data, even with a different $\epsilon$ , is generated using the same method as the black-box attack (FGSM). In contrast, Defense-GAN and MagNet are general defense mechanisms which do not assume a specific attack model.
+
+The performances of defenses on the F-MNIST dataset, shown in Table 2, are noticeably lower than on MNIST. This is due to the large $\epsilon = 0 . 3$ in the FGSM attack. Please see Appendix D for qualitative examples showing that $\epsilon = 0 . 3$ represents very high noise, which makes F-MNIST images difficult to classify, even by a human.
+
+In addition, the Defense-GAN parameters used in this experiment were kept the same for both Tables, in order to study the effect of dataset complexity, and can be further optimized as investigated in the next section.
+
+Table 1: Classification accuracies of different classifier and substitute model combinations using various defense strategies on the MNIST dataset, under FGSM black-box attacks with $\epsilon = 0 . 3$ . Defense-GAN has $L = 2 0 0$ and $R = 1 0$ .   
+
+<table><tr><td>Classifier/ Substitute</td><td>No Attack</td><td>No Defense</td><td>Defense- GAN-Rec</td><td>Defense- GAN-Orig</td><td>MagNet</td><td>Adv. Tr. ∈= 0.3</td><td>Adv. Tr. ∈= 0.15</td></tr><tr><td>A/B</td><td>0.9970</td><td>0.6343</td><td>0.9312</td><td>0.9282</td><td>0.6937</td><td>0.9654</td><td>0.6223</td></tr><tr><td>A/E</td><td>0.9970</td><td>0.5432</td><td>0.9139</td><td>0.9221</td><td>0.6710</td><td>0.9668</td><td>0.9327</td></tr><tr><td>B/B</td><td>0.9618</td><td>0.2816</td><td>0.9057</td><td>0.9105</td><td>0.5687</td><td>0.2092</td><td>0.3441</td></tr><tr><td>B/E</td><td>0.9618</td><td>0.2128</td><td>0.8841</td><td>0.8892</td><td>0.4627</td><td>0.1120</td><td>0.3354</td></tr><tr><td>C/B</td><td>0.9959</td><td>0.6648</td><td>0.9357</td><td>0.9322</td><td>0.7571</td><td>0.9834</td><td>0.9208</td></tr><tr><td>C/E</td><td>0.9959</td><td>0.8050</td><td>0.9223</td><td>0.9182</td><td>0.6760</td><td>0.9843</td><td>0.9755</td></tr><tr><td>D/B</td><td>0.9920</td><td>0.4641</td><td>0.9272</td><td>0.9323</td><td>0.6817</td><td>0.7667</td><td>0.8514</td></tr><tr><td>D/E</td><td>0.9920</td><td>0.3931</td><td>0.9164</td><td>0.9155</td><td>0.6073</td><td>0.7676</td><td>0.7129</td></tr></table>
+
+4.1.1 EFFECT OF NUMBER OF GD ITERATIONS $L$ AND RANDOM RESTARTS $R$
+
+Figure 3 shows the effect of varying the number of GD iterations $L$ as well as the random restarts $R$ used to compute the GAN reconstructions of input images. Across different $L$ and $R$ values, Defense-GAN-Rec and Defense-GAN-Orig have comparable performance. Increasing $L$ has the expected effect of improving performance when no attack is present. Interestingly, with an FGSM attack, the classification performance decreases after a certain $L$ value. With too many GD iterations on the mean squared error (MSE) $| | G ( \mathbf { z } ) - ( \mathbf { x } + \pmb { \delta } ) | | _ { 2 } ^ { 2 }$ , some of the adversarial noise components are retained. In the right Figure, the effect of varying $R$ is shown to be extremely pronounced. This is due to the non-convex nature of the MSE, and increasing $R$ enables us to sample different local minima.
+
+Table 2: Classification accuracies of different classifier and substitute model combinations using various defense strategies on the F-MNIST dataset, under FGSM black-box attacks with $\epsilon = 0 . 3$ . Defense-GAN has $L = 2 0 0$ and $R = 1 0$ .   
+
+<table><tr><td rowspan=1 colspan=8>Classifier/    No       No     Defense-    Defense-                Adv. Tr.  Adv. Tr.GAN-Orig  MagNetSubstituteAttackDefenseGAN-Rec  ∈= 0.3  ∈= 0.15</td></tr><tr><td rowspan=1 colspan=1>A/B</td><td rowspan=1 colspan=1>0.9346</td><td rowspan=1 colspan=1>0.5131</td><td rowspan=1 colspan=1>0.586</td><td rowspan=1 colspan=1>0.5803</td><td rowspan=1 colspan=1>0.5404</td><td rowspan=1 colspan=1>0.7393</td><td rowspan=1 colspan=1>0.6600</td></tr><tr><td rowspan=7 colspan=1>A/EB/BB/EC/BC/ED/BD/E</td><td rowspan=1 colspan=1>0.9346</td><td rowspan=1 colspan=1>0.3653</td><td rowspan=1 colspan=1>0.4790</td><td rowspan=1 colspan=1>0.4616</td><td rowspan=1 colspan=1>0.3311</td><td rowspan=1 colspan=1>0.6945</td><td rowspan=1 colspan=1>0.5638</td></tr><tr><td rowspan=1 colspan=1>0.7470</td><td rowspan=1 colspan=1>0.4017</td><td rowspan=1 colspan=1>0.4940</td><td rowspan=1 colspan=1>0.5530</td><td rowspan=1 colspan=1>0.3812</td><td rowspan=1 colspan=1>0.3177</td><td rowspan=1 colspan=1>0.3560</td></tr><tr><td rowspan=1 colspan=1>0.7470</td><td rowspan=1 colspan=1>0.3123</td><td rowspan=1 colspan=1>0.3720</td><td rowspan=1 colspan=1>0.4187</td><td rowspan=1 colspan=1>0.3119</td><td rowspan=1 colspan=1>0.2617</td><td rowspan=1 colspan=1>0.2453</td></tr><tr><td rowspan=1 colspan=1>0.9334</td><td rowspan=1 colspan=1>0.2635</td><td rowspan=1 colspan=1>0.5289</td><td rowspan=1 colspan=1>0.6079</td><td rowspan=1 colspan=1>0.4664</td><td rowspan=1 colspan=1>0.7791</td><td rowspan=1 colspan=1>0.6838</td></tr><tr><td rowspan=1 colspan=1>0.9334</td><td rowspan=1 colspan=1>0.2066</td><td rowspan=1 colspan=1>0.4871</td><td rowspan=1 colspan=1>0.4625</td><td rowspan=1 colspan=1>0.3016</td><td rowspan=1 colspan=1>0.7504</td><td rowspan=1 colspan=1>0.6655</td></tr><tr><td rowspan=1 colspan=1>0.8923</td><td rowspan=1 colspan=1>0.4541</td><td rowspan=1 colspan=1>0.5779</td><td rowspan=1 colspan=1>0.5853</td><td rowspan=1 colspan=1>0.5478</td><td rowspan=1 colspan=1>0.6172</td><td rowspan=1 colspan=1>0.6395</td></tr><tr><td rowspan=1 colspan=1>0.8923</td><td rowspan=1 colspan=1>0.2543</td><td rowspan=1 colspan=1>0.4007</td><td rowspan=1 colspan=1>0.4730</td><td rowspan=1 colspan=1>0.3396</td><td rowspan=1 colspan=1>0.5093</td><td rowspan=1 colspan=1>0.4962</td></tr></table>
+
+![](images/ef49b9d749182fbdadbaacf61ef40c0389958beabb853fe3cbc6bfc080783d5f.jpg)  
+Figure 3: Classification accuracy of Model F using Defense-GAN on the MNIST dataset, under FGSM black-box attacks with $\epsilon = 0 . 3$ and substitute Model E. Left: various number of iterations $L$ are used $R = 1 0$ ). Right: various number of random restarts $R$ are used $L = 1 0 0 _ { \rho }$ ).
+
+# 4.1.2 EFFECT OF ADVERSARIAL NOISE NORM 
+
+We now investigate the effect of changing the attack $\epsilon$ in Table 3. As expected, with higher $\epsilon$ , the FGSM attack is more successful, especially on the F-MNIST dataset where the noise norm seems to have a more pronounced effect with nearly $3 7 \%$ drop in performance between $\epsilon = 0 . 1$ and 0.3. Figure 7 in Appendix D shows adversarial samples as well as their reconstructions with DefenseGAN at different values of $\epsilon$ . We can see that for large $\epsilon$ , the class is difficult to discern, even for the human eye.
+
+Even though it seems that increasing $\epsilon$ is a desirable strategy for the attacker, this increases the likelihood that the adversarial noise is discernible and therefore the attack is detected. It is trivial for the attacker to provide adversarial images at very high $\epsilon$ , and a good measure of an attack’s strength is its ability to affect performance at low $\epsilon$ . In fact, in the next section, we discuss how Defense-GAN can be used to not only diminish the effect of attacks, but to also detect them.
+
+# 4.1.3 ATTACK DETECTION
+
+We intuitively expect that clean, unperturbed images will lie closer to the range of the Defense-GAN generator $G$ than adversarial examples. This is due to the fact that $G$ was trained to produce images which resemble the legitimate data. In light of this observation, we propose to use the MSE of an image with it is reconstruction from (8) as a “metric” to decide whether or not the image was adversarially manipulated. In order words, for a given threshold $\theta > 0$ , the hypothesis test is:
+
+Table 3: Classification accuracy of Model F using Defense-GAN $L = 4 0 0$ , $R = 1 0$ ), under FGSM black-box attacks for various noise norms $\epsilon$ and substitute Model E.   
+
+<table><tr><td>E</td><td>Defense-GAN-Rec MNIST</td><td>Defense-GAN-Rec F-MNIST</td></tr><tr><td>0.10</td><td>0.9864± 0.0011</td><td>0.8844± 0.0017</td></tr><tr><td>0.15 0.20</td><td>0.9836 ± 0.0026</td><td>0.8267 ± 0.0065</td></tr><tr><td></td><td>0.9772 ± 0.0019</td><td>0.7492 ± 0.0170</td></tr><tr><td>0.25</td><td>0.9641 ± 0.0001</td><td>0.6384 ± 0.0159</td></tr><tr><td>0.30</td><td>0.9307 ± 0.0034</td><td>0.5126 ± 0.0096</td></tr></table>
+
+![](images/163fa7f7e07aab9ee40ace3f0992cc6cbff0797ab2c94f478e77639fbc82b6e2.jpg)  
+Figure 4: ROC Curves when using Defense-GAN MSE for FGSM attack detections on the MNIST dataset (Classifier Model F, Substitute Model E). Left: Results for various number of GD iterations are shown with $R = 1 0$ , $\epsilon = 0 . 3 0$ . Middle: Results for various number of random restarts $R$ are shown with $L = 1 0 0$ , $\epsilon = 0 . 3 0$ . Right: Results for various $\epsilon$ are shown with $L = 4 0 0$ , $R = 1 0$ .
+
+$$
+| | G ( \mathbf { z } ^ { * } ) - \mathbf { x } | | _ { 2 } ^ { 2 } \qquad \mathbf { \geq } \qquad \theta .
+$$
+
+We compute the reconstruction MSEs for every image from the test dataset, and its adversarially manipulated version using FGSM. We show the Receiver Operating Characteristic (ROC) curves as well as the Area Under the Curve (AUC) metric for different Defense-GAN parameters and $\epsilon$ values in Figures 4 and 5. The results show that this attack detection strategy is effective especially when the number of GD iterations $L$ and random restarts $R$ are large. From the left and middle Figures, we can conclude that the number of random restarts plays a very important role in the detection false positive and true positive rates as was discussed in Section 4.1.1. Furthermore, when $\epsilon$ is very small, it becomes difficult to detect attacks at low false positive rates.
+
+# 4.1.4 RESULTS ON WHITE-BOX ATTACKS
+
+We now present results on white-box attacks using three different strategies: FGSM, RAND $+$ FGSM, and CW. We perform the CW attack for 100 iterations of projected GD, with learning rate 10.0, and use $c = 1 0 0$ in equation (4). Table 4 shows the classification performance of different classifier models across different attack and defense strategies. We note that Defense-GAN significantly outperforms the two other baseline defenses. We even give the adversarial attacker access to the random initializations of $\mathbf { z }$ . However, we noticed that the performance does not change much when the attacker does not know the initialization. Adversarial training was done using FGSM to generate the adversarial samples. It is interesting to mention that when CW attack is used, adversarial training performs extremely poorly. As previously discussed, adversarial training does not generalize well against different attack methods.
+
+Due to the loop of $L$ steps of GD, Defense-GAN is resilient to GD-based white-box attacks, since the attacker needs to “un-roll” the GD loop and propagate the gradient of the loss all the way across $L$ steps. In fact, from Table 4, the performance of classifier A with Defense-GAN on the MNIST dataset drops less than $1 \%$ from 0.997 to 0.988 under FGSM. In comparison, from Figure 8, when
+
+![](images/a97aa9d440eb1e14969ccc08ba7322d32e599add67c09aa987ddb6115d2bd4a2.jpg)  
+Figure 5: ROC Curves when using Defense-GAN MSE for FGSM attack detections on the F-MNIST dataset (Classifier Model F, Substitute Model E). Left: Results for various number of GD iterations are shown with $R = 1 0$ , $\epsilon = 0 . 3 0$ . Middle: Results for various number of random restarts $R$ are shown with $L = 1 0 0$ , $\epsilon = 0 . 3 0$ . Right: Results for various $\epsilon$ are shown with $L = 2 0 0$ , $R = 1 0$ .
+
+$L = 2 5$ , the performance of the same network drops to 0.947 (more than $5 \%$ drop). This shows that using a larger $L$ significantly increases the robustness of Defense-GAN against GD-based whitebox attacks. This comes at the expense of increased inference time complexity. We present a more detailed discussion about the difficulty of GD-based white-box attacks in Appendix B and time complexity in Appendix G. Additional white-box experimental results on higher-dimensional images are reported in Appendix F.
+
+Table 4: Classification accuracies of different classifier models using various defense strategies on the MNIST (top) and F-MNIST (bottom) datasets, under FGSM, RAND $+$ FGSM, and CW white-box attacks. Defense-GAN has $L = 2 0 0$ and $R = 1 0$ .   
+
+<table><tr><td rowspan=1 colspan=10>Classifier   No      No     Defense-               Adv. Tr.Attack                                                            MagNet  ∈ = 0.3Model   Attack Defense  GAN-Rec</td></tr><tr><td rowspan=3 colspan=1>FGSM∈= 0.3</td><td rowspan=3 colspan=1>ABCD</td><td rowspan=1 colspan=1>0.9970.962</td><td rowspan=3 colspan=1>0.2170.0220.3310.038</td><td rowspan=3 colspan=2>0.9880.9560.9890.980</td><td rowspan=1 colspan=3>0.1910.082</td><td rowspan=1 colspan=1>0.6510.060</td></tr><tr><td rowspan=2 colspan=1>0.9960.992</td><td rowspan=1 colspan=3>0.163</td><td rowspan=1 colspan=1>0.786</td></tr><tr><td rowspan=1 colspan=3>0.094</td><td rowspan=1 colspan=1>0.732</td></tr><tr><td rowspan=6 colspan=1>RAND+FGSM∈ = 0.3,α = 0.05</td><td rowspan=6 colspan=1>ABCD</td><td rowspan=6 colspan=1>0.9970.9620.9960.992</td><td rowspan=6 colspan=1>0.1790.0170.1030.050</td><td rowspan=2 colspan=2>0.9880.944</td><td rowspan=1 colspan=3>0.171</td><td rowspan=1 colspan=1>0.774</td></tr><tr><td rowspan=1 colspan=3>0.091</td><td rowspan=1 colspan=1>0.138</td></tr><tr><td rowspan=4 colspan=2>0.9850.980</td><td rowspan=1 colspan=1></td><td></td><td></td><td></td></tr><tr><td rowspan=2 colspan=2>0.</td><td></td><td></td></tr><tr><td rowspan=1 colspan=2>0.151</td><td rowspan=1 colspan=1>0.907</td></tr><tr><td rowspan=1 colspan=3>0.115</td><td rowspan=1 colspan=1>0.539</td></tr><tr><td rowspan=3 colspan=1>CWl2 norm</td><td rowspan=3 colspan=1>ABCD</td><td rowspan=2 colspan=1>0.9970.962</td><td rowspan=2 colspan=1>0.1410.032</td><td rowspan=2 colspan=2>0.9890.916</td><td rowspan=1 colspan=3>0.038</td><td rowspan=1 colspan=1>0.077</td></tr><tr><td rowspan=1 colspan=1>0.032</td><td rowspan=1 colspan=1>0.916</td><td rowspan=1 colspan=3>0.034</td><td rowspan=1 colspan=1>0.280</td></tr><tr><td rowspan=1 colspan=1>0.9960.992</td><td rowspan=1 colspan=1>0.1260.032</td><td rowspan=1 colspan=2>0.9890.983</td><td rowspan=1 colspan=3>0.0250.021</td><td rowspan=1 colspan=1>0.0310.010</td></tr><tr><td rowspan=1 colspan=1>Attack</td><td rowspan=1 colspan=1>ClassifierModel</td><td rowspan=1 colspan=1>NoAttack</td><td rowspan=1 colspan=1>NoDefense</td><td rowspan=1 colspan=2>Defense-GAN-Rec</td><td rowspan=1 colspan=3>MagNet</td><td rowspan=1 colspan=1>Adv. Tr.∈= 0.3</td></tr><tr><td rowspan=4 colspan=1>FGSM∈= 0.3</td><td rowspan=4 colspan=1>ABCD</td><td rowspan=2 colspan=1>0.9340.747</td><td rowspan=1 colspan=1>0.102</td><td rowspan=1 colspan=2>0.879</td><td rowspan=1 colspan=3>0.089</td><td rowspan=3 colspan=1>0.7970.1360.804</td></tr><tr><td rowspan=2 colspan=1>0.1020.139</td><td rowspan=2 colspan=2>0.6290.896</td><td rowspan=1 colspan=3>0.168</td></tr><tr><td rowspan=1 colspan=1>0.933</td><td rowspan=1 colspan=3>0.110</td></tr><tr><td rowspan=1 colspan=1>0.892</td><td rowspan=1 colspan=1>0.082</td><td rowspan=1 colspan=2>0.875</td><td rowspan=1 colspan=3>0.099</td><td rowspan=1 colspan=1>0.698</td></tr><tr><td rowspan=3 colspan=1>RAND+FGSM∈ = 0.3,α = 0.05</td><td rowspan=3 colspan=1>ABCD</td><td rowspan=3 colspan=1>0.9340.7470.9330.892</td><td rowspan=1 colspan=1>0.102</td><td rowspan=1 colspan=2>0.888</td><td rowspan=1 colspan=3>0.096</td><td rowspan=2 colspan=1>0.4470.1190.699</td></tr><tr><td rowspan=2 colspan=1>0.1310.1050.091</td><td rowspan=1 colspan=2>0.6610.893</td><td rowspan=1 colspan=3>0.1610.112</td></tr><tr><td rowspan=1 colspan=2>0.862</td><td rowspan=1 colspan=3>0.104</td><td rowspan=1 colspan=1>0.626</td></tr><tr><td rowspan=4 colspan=1>CWl2 norm</td><td rowspan=4 colspan=1>ABCD</td><td rowspan=1 colspan=1>0.934</td><td rowspan=1 colspan=1>0.076</td><td rowspan=1 colspan=2>0.896</td><td rowspan=1 colspan=3>0.060</td><td rowspan=1 colspan=1>0.157</td></tr><tr><td rowspan=2 colspan=1>0.7470.933</td><td rowspan=1 colspan=1>0.172</td><td rowspan=1 colspan=2>0.656</td><td rowspan=1 colspan=3>0.131</td><td rowspan=1 colspan=1>0.118</td></tr><tr><td rowspan=1 colspan=1>0.063</td><td rowspan=1 colspan=2>0.896</td><td rowspan=1 colspan=3>0.084</td><td rowspan=1 colspan=1>0.107</td></tr><tr><td rowspan=1 colspan=1>0.892</td><td rowspan=1 colspan=1>0.090</td><td rowspan=1 colspan=2>0.875</td><td rowspan=1 colspan=3>0.069</td><td rowspan=1 colspan=1>0.149</td></tr></table>
+
+# 5 CONCLUSION
+
+In this paper, we proposed Defense-GAN, a novel defense strategy utilizing GANs to enhance the robustness of classification models against black-box and white-box adversarial attacks. Our method does not assume a particular attack model and was shown to be effective against most commonly considered attack strategies. We empirically show that Defense-GAN consistently provides adequate defense on two benchmark computer vision datasets, whereas other methods had many shortcomings on at least one type of attack.
+
+It is worth mentioning that, although Defense-GAN was shown to be a feasible defense mechanism against adversarial attacks, one might come across practical difficulties while implementing and deploying this method. The success of Defense-GAN relies on the expressiveness and generative power of the GAN. However, training GANs is still a challenging task and an active area of research, and if the GAN is not properly trained and tuned, the performance of Defense-GAN will suffer on both original and adversarial examples. Moreover, the choice of hyper-parameters $L$ and $R$ is also critical to the effectiveness of the defense and it may be challenging to tune them without knowledge of the attack.
+
+# ACKNOWLEDGMENT
+
+This research is based upon work supported by the Office of the Director of National Intelligence (ODNI), Intelligence Advanced Research Projects Activity (IARPA), via IARPA R&D Contract No. 2014-14071600012. The views and conclusions contained herein are those of the authors and should not be interpreted as necessarily representing the official policies or endorsements, either expressed or implied, of the ODNI, IARPA, or the U.S. Government. The U.S. Government is authorized to reproduce and distribute reprints for Governmental purposes notwithstanding any copyright annotation thereon.
+
+# REFERENCES
+
+Mart´ın Abadi et al. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015. URL http://tensorflow.org/. Software available from tensorflow.org.   
+Martin Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein GAN. ´ arXiv preprint arXiv:1701.07875, 2017.   
+Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In IEEE Symposium on Security and Privacy, 2017.   
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in Neural Information Processing Systems, 2014.   
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. International Conference on Learning Representations, 2015.   
+Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron Courville. Improved training of Wasserstein GANs. arXiv preprint arXiv:1704.00028, 2017.   
+Dan Hendrycks and Kevin Gimpel. Early methods for detecting adversarial images. International Conference on Learning Representations, Workshop Track, 2017.   
+Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. 2014.   
+Maya Kabkab, Pouya Samangouei, and Rama Chellappa. Task-aware compressed sensing with generative models. In AAAI Conference on Artificial Intelligence, 2018.   
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. International Conference on Learning Representations, Workshop Track, 2017.   
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. International Conference on Learning Representations, 2017.
+
+Ziwei Liu, Ping Luo, Xiaogang Wang, and Xiaoou Tang. Deep learning face attributes in the wild. In IEEE International Conference on Computer Vision, 2015.
+
+Dongyu Meng and Hao Chen. MagNet: a two-pronged defense against adversarial examples. arXiv preprint arXiv:1705.09064, 2017.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: a simple and accurate method to fool deep neural networks. In IEEE Conference on Computer Vision and Pattern Recognition, 2016.
+
+Nicolas Papernot, Ian Goodfellow, Ryan Sheatsley, Reuben Feinman, and Patrick McDaniel. Cleverhans v1. 0.0: an adversarial machine learning library. arXiv preprint arXiv:1610.00768, 2016a.
+
+Nicolas Papernot, Patrick McDaniel, Somesh Jha, Matt Fredrikson, Z Berkay Celik, and Ananthram Swami. The limitations of deep learning in adversarial settings. In IEEE Symposium on Security and Privacy, 2016b.
+
+Nicolas Papernot, Patrick McDaniel, Arunesh Sinha, and Michael Wellman. Towards the science of security and privacy in machine learning. arXiv preprint arXiv:1611.03814, 2016c.
+
+Nicolas Papernot, Patrick McDaniel, Xi Wu, Somesh Jha, and Ananthram Swami. Distillation as a defense to adversarial perturbations against deep neural networks. In IEEE Symposium on Security and Privacy, 2016d.
+
+Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against machine learning. In ACM Asia Conference on Computer and Communications Security, 2017.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. International Conference on Learning Representations, Workshop Track, 2014.
+
+Florian Tramer, Alexey Kurakin, Nicolas Papernot, Dan Boneh, and Patrick McDaniel. Ensemble \` adversarial training: Attacks and defenses. arXiv preprint arXiv:1705.07204, 2017.
+
+Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-MNIST: a novel image dataset for benchmarking machine learning algorithms. arXiv preprint arXiv:1708.07747, 2017.
+
+# Appendices
+
+A OPTIMALITY OF $p _ { g } = p _ { \mathrm { D A T A } }$ FOR WGANS
+
+Sketch of proof of Lemma 1: The WGAN min-max loss is given by:
+
+$$
+\begin{array} { l l l } { { \displaystyle V _ { W } ( D , G ) = \mathbb { E } _ { { \bf x } \sim p _ { \mathrm { d a t a } } ( { \bf x } ) } [ D ( { \bf x } ) ] - \mathbb { E } _ { { \bf z } \sim p _ { \bf z } ( { \bf z } ) } [ D ( G ( { \bf z } ) ) ] } \ ~ } \\ { { \displaystyle ~ = \int _ { { \bf x } } p _ { \mathrm { d a t a } } ( { \bf x } ) D ( { \bf x } ) d { \bf x } - \int _ { { \bf z } } p _ { { \bf z } } ( { \bf z } ) D ( G ( { \bf z } ) ) d { \bf z } } \ ~ } \\ { { \displaystyle ~ = \int _ { { \bf x } } \left( p _ { \mathrm { d a t a } } ( { \bf x } ) - p _ { g } ( { \bf x } ) \right) D ( { \bf x } ) d { \bf x } } } \end{array}
+$$
+
+For a fixed $G$ , the optimal discriminator $D$ which maximizes $V _ { W } ( D , G )$ is such that:
+
+$$
+D _ { G } ^ { * } ( \mathbf { x } ) = \left\{ { \begin{array} { l l } { 1 } & { \mathrm { i f } \ p _ { \mathrm { d a t a } } ( \mathbf { x } ) \geq p _ { g } ( \mathbf { x } ) } \\ { 0 } & { \mathrm { o t h e r w i s e } } \end{array} } \right.
+$$
+
+Plugging $D _ { G } ^ { * }$ back into (12), we get:
+
+$$
+\begin{array} { l } { { \displaystyle V _ { W } ( D _ { G } ^ { * } , G ) = \int _ { \mathbf { x } } \left( p _ { \mathrm { d a t a } } ( \mathbf { x } ) - p _ { g } ( \mathbf { x } ) \right) D _ { G } ^ { * } ( \mathbf { x } ) d \mathbf { x } } \ ~ } \\ { { \displaystyle ~ = \int _ { \left\{ \mathbf { x } \mid p _ { \mathrm { d a t a } } ( \mathbf { x } ) \geq p _ { g } ( \mathbf { x } ) \right\} } \left( p _ { \mathrm { d a t a } } ( \mathbf { x } ) - p _ { g } ( \mathbf { x } ) \right) d \mathbf { x } } } \ ~  \end{array}
+$$
+
+Let $\mathcal { X } = \{ \mathbf { x } \mid p _ { \mathrm { d a t a } } ( \mathbf { x } ) \geq p _ { g } ( \mathbf { x } ) \}$ . Clearly, to minimize (15), we need to set $p _ { \mathrm { d a t a } } ( \mathbf { x } ) = p _ { g } ( \mathbf { x } )$ for $\mathbf { x } \in \mathcal { X }$ . Then, since both pdfs should integrate to 1,
+
+$$
+\int _ { \mathcal { X } ^ { c } } p _ { g } ( \mathbf { x } ) d \mathbf { x } = \int _ { \mathcal { X } ^ { c } } p _ { \mathrm { d a t a } } ( \mathbf { x } ) d \mathbf { x }
+$$
+
+However, this is a contradiction since $p _ { g } ( \mathbf { x } ) < p _ { \mathrm { d a t a } } ( \mathbf { x } )$ for $\mathbf { x } \in \mathcal { X } ^ { c }$ , unless $\mu ( \mathcal { X } ^ { c } ) = 0$ where $\mu$ is the Lebesgue measure. This concludes the proof.
+
+# B DIFFICULTY OF GD-BASED WHITE-BOX ATTACKS ON DEFENSE-GAN
+
+In order to perform a GD-based white-box attack on models using Defense-GAN, an attacker needs to compute the gradient of the output of the classifier with respect to the input. From Figure 1, the generator and the classifier can be seen as one, combined, feedforward network, through which it is easy to propagate gradients. The difficulty lies in the orange box of the GD optimization detailed in Figure 2.
+
+For the sake of simplicity, let’s assume that $R = 1$ . Define $\mathcal { L } ( \mathbf { x } , \mathbf { z } ) = | | G ( \mathbf { z } ) - \mathbf { x } | | _ { 2 } ^ { 2 }$ . Then ${ \bf z } ^ { * } = { \bf z } _ { L }$ which is computed recursively as follows:
+
+$$
+\begin{array} { r l } & { \mathbf { z } _ { 1 } = \mathbf { z } _ { 0 } + \eta _ { 0 } \left. \nabla _ { \mathbf { z } } \mathcal { L } ( \mathbf { x } , \mathbf { z } ) \right| _ { \mathbf { z } = \mathbf { z } _ { 0 } } } \\ & { \mathbf { z } _ { 2 } = \mathbf { z } _ { 1 } + \eta _ { 1 } \left. \nabla _ { \mathbf { z } } \mathcal { L } ( \mathbf { x } , \mathbf { z } ) \right| _ { \mathbf { z } = \mathbf { z } _ { 1 } } } \\ & { \quad = \mathbf { z } _ { 0 } + \eta _ { 0 } \left. \nabla _ { \mathbf { z } } \mathcal { L } ( \mathbf { x } , \mathbf { z } ) \right| _ { \mathbf { z } = \mathbf { z } _ { 0 } } + \eta _ { 1 } \left. \nabla _ { \mathbf { z } } \mathcal { L } ( \mathbf { x } , \mathbf { z } ) \right| _ { \mathbf { z } = \mathbf { z } _ { 0 } + \eta _ { 0 } \left. \nabla _ { \mathbf { z } } \mathcal { L } ( \mathbf { x } , \mathbf { z } ) \right| _ { \mathbf { z } = \mathbf { z } _ { 0 } } } } \end{array}
+$$
+
+and so on. Therefore, computing the gradient of $\mathbf { z } ^ { \ast }$ with respect to $\mathbf { x }$ involves a large number $( L )$ of recursive chain rules and high-dimensional Jacobian tensors. This computation gets increasingly prohibitive for large $L$ .
+
+# C NEURAL NETWORK ARCHITECTURES
+
+We describe the neural network architectures used throughout the paper. The detail of models A through F used for classifier and substitute networks can be found in Table 5. In Table 6, the GAN architectures are described, and in Table 7, the encoder architecture for the MagNet baseline is given. In what follows:
+
+• $\mathrm { C o n v } ( m , k \times k , s )$ refers to a convolutional layer with $m$ feature maps, filter size $k \times k$ , and stride $s$   
+• $\mathrm { C o n v T } ( m , \ k \times \ k )$ refers to the transpose (gradient) of Conv (sometimes referred to as “deconvolution”) with $m$ feature maps, filter size $k \times k$ , and stride $s$   
+• $\operatorname { F C } ( m )$ refers to a fully-connected layer with $m$ outputs   
+• Dropout $( p )$ refers to a dropout layer with probability $p$   
+• ReLU refers to the Rectified Linear Unit activation   
+• LeakyReLU $( \alpha )$ is the leaky version of the Rectified Linear Unit with parameter $\alpha$
+
+Table 5: Neural network architectures used for classifiers and substitute models.   
+
+<table><tr><td>A</td><td>B,F*</td><td>C</td><td>D,E*</td></tr><tr><td>Conv(64,5 × 5,1) ReLU Conv(64,5 × 5,2) ReLU Dropout(0.25) FC(128) ReLU</td><td>Dropout(0.2) Conv(64,8 × 8,2) ReLU Conv(128,6 × 6,2) ReLU Conv(128,5 × 5,1)</td><td>Conv(128,3 × 3,1) ReLU Conv(64,3 × 3, 2) ReLU Dropout(0.25) FC(128)</td><td>FC(200) ReLU Dropout(0.5) FC(200) ReLU Dropout(0.5)</td></tr></table>
+
+$[ \mathbf { \Psi } ^ { * } : \mathrm { F }$ (resp. E) shares the same architecture as B (resp. D) with the dropout layers removed ]
+
+Table 6: Neural network architectures used for GANs.   
+
+<table><tr><td colspan="2">Generator Discriminator</td></tr><tr><td>FC(4096) ReLU ConvT(256,5 × 5,1)</td><td>Conv(64,5 × 5,2) LeakyReLU(0.2)</td></tr><tr><td>ReLU</td><td>Conv(128,5 × 5,2) LeakyReLU(0.2)</td></tr><tr><td>ConvT(128,5 × 5,1) ReLU</td><td>Conv(256,5 × 5,2)</td></tr><tr><td>ConvT(1, 5 × 5,1)</td><td>LeakyReLU(0.2) FC(1)</td></tr><tr><td>Sigmoid</td><td>Sigmoid</td></tr></table>
+
+Table 7: Neural network architecture used for the MagNet encoder.   
+
+<table><tr><td>Encoder</td></tr><tr><td>Conv(64, 5 × 5, 2)</td></tr><tr><td>LeakyReLU(0.2)</td></tr><tr><td>Conv(128,5 × 5,2)</td></tr><tr><td>LeakyReLU(0.2)</td></tr><tr><td>Conv(256,5 × 5,2)</td></tr><tr><td>LeakyReLU(0.2) FC(128)+tanh</td></tr></table>
+
+![](images/bfcd40c8ca827f2db51c2d2b2361e6bff91f60e9afd24ce6f20c7f7bb9533b5c.jpg)  
+Figure 6: Examples from MNIST and F-MNIST. Left: Original, FGSM adversarial $\epsilon = 0 . 3$ , and reconstruction images for $R = 1$ and various $L$ are shown. Right: Original, FGSM adversarial $\epsilon = 0 . 3$ , and reconstruction images for $L = 2 5$ and various $R$ are shown.
+
+![](images/707b2e54e93c9d85ad370acc954afa588e53c1303a700d0630b97dae3c2859f6.jpg)  
+Figure 7: Examples from MNIST and F-MNIST: Original, FGSM adversarial and reconstruction images for $L = 5 0$ , $R = 1 5$ and various $\epsilon$ are shown.
+
+# E ADDITIONAL RESULTS ON THE EFFECT OF VARYING THE NUMBER OF GD ITERATIONS $L$ AND RANDOM RESTARTS $R$
+
+Table 8: Classification accuracy of Model F using Defense-GAN with various number of iterations $L$ $R = 1 0$ ), on the MNIST dataset, under FGSM black-box attack with $\epsilon = 0 . 3$ .   
+
+<table><tr><td>L</td><td>Defense-GAN-Rec No attack</td><td>Defense-GAN-Orig No attack</td><td>Defense-GAN-Rec Adversarial</td><td>Defense-GAN-Orig Adversarial</td></tr><tr><td>25</td><td>0.9273± 0.0215</td><td>0.9141± 0.0033</td><td>0.7955± 0.0045</td><td>0.7998± 0.0063</td></tr><tr><td>50</td><td>0.9567 ± 0.0203</td><td>0.9371 ± 0.0048</td><td>0.8516 ± 0.0078</td><td>0.8472 ± 0.0026</td></tr><tr><td>100</td><td>0.9728 ± 0.0164</td><td>0.9560 ± 0.0051</td><td>0.8953 ± 0.0027</td><td>0.8911 ± 0.0024</td></tr><tr><td>200</td><td>0.9860 ± 0.0010</td><td>0.9712 ± 0.0028</td><td>0.9210 ± 0.0023</td><td>0.9155 ± 0.0032</td></tr><tr><td>400</td><td>0.9869 ± 0.0082</td><td>0.9808 ± 0.0044</td><td>0.9332 ± 0.0027</td><td>0.9307 ± 0.0034</td></tr><tr><td>800</td><td>0.9934 ± 0.0009</td><td>0.9938 ± 0.0004</td><td>0.9319 ± 0.0038</td><td>0.9216 ± 0.0005</td></tr><tr><td>1600</td><td>0.9963 ± 0.0013</td><td>0.9967 ± 0.0005</td><td>0.9081 ± 0.0062</td><td>0.9008 ± 0.0095</td></tr></table>
+
+Table 9: Classification accuracy of Model F using Defense-GAN with various number of iterations $L$ $( R = 1 0 )$ ), on the F-MNIST dataset, under FGSM black-box attack with $\epsilon = 0 . 3$ .   
+
+<table><tr><td rowspan=1 colspan=5>Defense-GAN-Rec  Defense-GAN-Orig  Defense-GAN-Rec  Defense-GAN-OrigLNo attack             No attack            Adversarial           Adversarial</td></tr><tr><td rowspan=1 colspan=1>25</td><td rowspan=1 colspan=1>0.8037± 0.0050</td><td rowspan=1 colspan=1>0.7595 ± 0.0009</td><td rowspan=1 colspan=1>0.4040± 0.0149</td><td rowspan=1 colspan=1>0.3910± 0.0119</td></tr><tr><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>0.8676 ± 0.0018</td><td rowspan=1 colspan=1>0.7898 ± 0.0016</td><td rowspan=1 colspan=1>0.4412 ± 0.0023</td><td rowspan=1 colspan=1>0.3980 ± 0.0114</td></tr><tr><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>0.9101 ± 0.0032</td><td rowspan=1 colspan=1>0.8190 ± 0.0043</td><td rowspan=1 colspan=1>0.4808 ± 0.0088</td><td rowspan=2 colspan=1>0.4221 ± 0.02550.4594 ± 0.0056</td></tr><tr><td rowspan=1 colspan=1>200</td><td rowspan=1 colspan=1>0.9145 ± 0.0014</td><td rowspan=1 colspan=1>0.8373 ± 0.0054</td><td rowspan=1 colspan=1>0.5119 ± 0.0038</td></tr><tr><td rowspan=1 colspan=1>400</td><td rowspan=1 colspan=1>0.9490 ± 0.0013</td><td rowspan=1 colspan=1>0.8557 ± 0.0049</td><td rowspan=1 colspan=1>0.5126 ± 0.0096</td><td rowspan=1 colspan=1>0.4754 ± 0.0102</td></tr><tr><td rowspan=1 colspan=1>800</td><td rowspan=1 colspan=1>0.9588 ± 0.0065</td><td rowspan=1 colspan=1>0.8832 ± 0.0042</td><td rowspan=1 colspan=1>0.5520 ± 0.0098</td><td rowspan=1 colspan=1>0.4644± 0.0092</td></tr><tr><td rowspan=1 colspan=1>1600</td><td rowspan=1 colspan=1>0.9640 ± 0.0010</td><td rowspan=1 colspan=1>0.9125 ± 0.0040</td><td rowspan=1 colspan=1>0.5335 ± 0.0226</td><td rowspan=1 colspan=1>0.4952 ± 0.0155</td></tr></table>
+
+Table 10: Classification accuracy of Model F using Defense-GAN with various number of random restarts $R$ $L = 1 0 0$ ), on the MNIST dataset, under FGSM black-box attack with $\epsilon = 0 . 3$ .   
+
+<table><tr><td>R</td><td>Defense-GAN-Rec No attack</td><td>Defense-GAN-Orig No attack</td><td>Defense-GAN-Rec Adversarial</td><td>Defense-GAN-Orig Adversarial</td></tr><tr><td>1</td><td>0.7035± 0.0035</td><td>0.6436± 0.0017</td><td>0.5329±0.0094</td><td>0.5011 ± 0.0085</td></tr><tr><td>2</td><td>0.8619 ± 0.0010</td><td>0.8080 ± 0.0029</td><td>0.6722 ± 0.0041</td><td>0.6605 ± 0.0050</td></tr><tr><td>5</td><td>0.9523 ± 0.0006</td><td>0.9213 ± 0.0024</td><td>0.8199 ± 0.0097</td><td>0.8228 ± 0.0038</td></tr><tr><td>10</td><td>0.9810 ± 0.0015</td><td>0.9560 ± 0.0051</td><td>0.8956 ± 0.0032</td><td>0.8911 ± 0.0024</td></tr><tr><td>20</td><td>0.9966 ± 0.0009</td><td>0.9753 ± 0.0010</td><td>0.9456 ± 0.0031</td><td>0.9310 ± 0.0023</td></tr></table>
+
+Table 11: Classification accuracy of Model F using Defense-GAN with various number of random restarts $R$ $L = 1 0 0 _ { , }$ ), on the F-MNIST dataset, under FGSM black-box attack with $\epsilon = 0 . 3$ .   
+Classification accuracy of different models using Defense-GAN and varying L.   
+
+<table><tr><td>R</td><td>Defense-GAN-Rec No attack</td><td>Defense-GAN-Orig No attack</td><td>Defense-GAN-Rec Adversarial</td><td>Defense-GAN-Orig Adversarial</td></tr><tr><td>1</td><td>0.8425 ± 0.0008</td><td>0.5597± 0.0015</td><td>0.3504 ± 0.0102</td><td>0.3380± 0.0043</td></tr><tr><td>2</td><td>0.8994 ± 0.0051</td><td>0.7793 ± 0.0023</td><td>0.4050 ± 0.0148</td><td>0.3508 ± 0.0167</td></tr><tr><td>5</td><td>0.9260 ± 0.0028</td><td>0.6726 ± 0.0006</td><td>0.4521 ± 0.0177</td><td>0.4024 ± 0.0085</td></tr><tr><td>10</td><td>0.9101 ± 0.0032</td><td>0.8190 ± 0.0043</td><td>0.4808 ± 0.0088</td><td>0.4221 ± 0.0255</td></tr></table>
+
+![](images/280a6b6d6a47edaa07ba7894732e009a03590a786c188c2dd4089007f4b1337e.jpg)
+
+Figure 8: Classification accuracy of different models using Defense-GAN on the MNIST dataset, under FGSM white-box attack with $\epsilon = 0 . 3$ , for various number of iterations $L$ and $R = 1 0$ .
+
+# F ADDITIONAL RESULTS ON WHITE-BOX ATTACKS
+
+We report results on white-box attacks on the CelebFaces Attributes dataset (CelebA) (Liu et al., 2015) in Table 12. The CelebA dataset is a large-scale face dataset consisting of more than 200, 000 face images, split into training, validation, and testing sets. The RGB images were center-cropped
+
+and resized to $6 4 \times 6 4$ . We performed the task of gender classification on this dataset. The GAN architecture is the same as that in Table 6, except for an additional ConvT(128, $5 \times 5 , 1$ ) layer in the generator network.
+
+Table 12: Classification accuracies of different classifier models using various defense strategies on the CelebA gender classification task, under FGSM, RAND $+$ FGSM, and CW white-box attacks. Defense-GAN has $L = 2 0 0$ and $R = 2$ .   
+
+<table><tr><td rowspan=1 colspan=9>Classifier   No      No     Defense-               Adv. Tr.Attack                                                            MagNetModel   Attack Defense  GAN-Rec              ∈ = 0.3</td></tr><tr><td rowspan=4 colspan=1>FGSM∈= 0.3</td><td rowspan=4 colspan=1>ABCD</td><td rowspan=1 colspan=3>0.9652</td><td rowspan=1 colspan=1>0.0870</td><td rowspan=1 colspan=1>0.9255</td><td rowspan=1 colspan=1>0.0985</td><td rowspan=1 colspan=1>0.1225</td></tr><tr><td rowspan=1 colspan=3>0.9468</td><td rowspan=2 colspan=1>0.09950.0460</td><td rowspan=2 colspan=1>0.91400.9255</td><td rowspan=1 colspan=1>0.0920</td><td rowspan=1 colspan=1>0.2345</td></tr><tr><td rowspan=2 colspan=3>0.94590.9476</td><td rowspan=1 colspan=2>0.9459</td><td rowspan=1 colspan=1>59</td><td rowspan=1 colspan=1>0.1085</td><td rowspan=1 colspan=1>0.1130</td></tr><tr><td rowspan=1 colspan=1>0.0605</td><td rowspan=1 colspan=1>0.9205</td><td rowspan=1 colspan=1>0.0975</td><td rowspan=1 colspan=1>0.7755</td></tr><tr><td rowspan=4 colspan=1>RAND+FGSM∈ = 0.3,α = 0.05</td><td rowspan=4 colspan=1>ABCD</td><td rowspan=4 colspan=3>0.96520.94680.94590.9476</td><td rowspan=4 colspan=1>0.05600.17850.04700.0665</td><td rowspan=1 colspan=1>0.9280</td><td rowspan=1 colspan=1>0.1105</td><td rowspan=1 colspan=1>0.0700</td></tr><tr><td rowspan=2 colspan=1>0.90300.9200</td><td rowspan=2 colspan=1>0.10150.1045</td><td rowspan=1 colspan=1>0.4515</td></tr><tr><td rowspan=1 colspan=1>0.1055</td></tr><tr><td rowspan=1 colspan=1>0.9165</td><td rowspan=1 colspan=1>0.1105</td><td rowspan=1 colspan=1>0.696</td></tr><tr><td rowspan=4 colspan=1>CWl2 norm</td><td rowspan=4 colspan=1>ABCD</td><td rowspan=1 colspan=3>0.9652</td><td rowspan=1 colspan=1>0.0460</td><td rowspan=1 colspan=1>0.8210</td><td rowspan=1 colspan=1>0.0985</td><td rowspan=1 colspan=1>0.5690</td></tr><tr><td rowspan=1 colspan=3>0.9468</td><td rowspan=2 colspan=1>0.05750.0435</td><td rowspan=2 colspan=1>0.74650.7985</td><td rowspan=1 colspan=1>0.0955</td><td rowspan=2 colspan=1>0.07250.2635</td></tr><tr><td rowspan=2 colspan=3>0.94590.9476</td><td rowspan=1 colspan=1>0.0985</td></tr><tr><td rowspan=1 colspan=1>0.0660</td><td rowspan=1 colspan=1>0.7740</td><td rowspan=1 colspan=1>0.1040</td><td rowspan=1 colspan=1>0.5010</td></tr></table>
+
+# G TIME COMPLEXITY
+
+The computational complexity of reconstructing an image using Defense-GAN is on the order of the number of GD iterations performed to estimate $\mathbf { z } ^ { \ast }$ , multiplied by the time to compute gradients. The number of random restarts $R$ has less effect on the running time, since random restarts are independent and can run in parallel if enough resources are available. Table 13 shows the average running time, in seconds, to find the reconstructions of MNIST and F-MNIST images on one NVIDIA GeForce GTX TITAN X GPU. For most applications, these running times are not prohibitive. We can see a tradeoff between running time and defense robustness as well as accuracy.
+
+Table 13: Average time, in seconds, to compute reconstructions of MNIST/F-MNIST images for various values of $L$ and $R$ .   
+
+<table><tr><td></td><td>L=10</td><td>L = 25</td><td>L= 50</td><td>L=100</td><td>L= 200</td></tr><tr><td>R=1</td><td>0.043±0.027</td><td>0.070±0.003</td><td>0.137± 0.004</td><td>0.273±0.006</td><td>L= 0.543±0.017</td></tr><tr><td>R=2</td><td>0.042 ± 0.026</td><td>0.067 ± 0.002</td><td>0.131 ± 0.003</td><td>0.261 ± 0.006</td><td>L = 0.510± 0.006</td></tr><tr><td>R=5</td><td>0.043 ± 0.029</td><td>0.070 ± 0.002</td><td>0.136 ± 0.004</td><td>0.270 ± 0.004</td><td>L = 0.535 ± 0.008</td></tr><tr><td>R=10</td><td>0.051 ± 0.032</td><td>0.086 ± 0.001</td><td>0.170±0.002</td><td>0.338 ± 0.008</td><td>L = 0.675 ± 0.016</td></tr><tr><td>R=20</td><td>0.060 ± 0.035</td><td>0.105 ± 0.003</td><td>0.209 ±0.006</td><td>0.414 ± 0.012</td><td>L = 0.825 ± 0.022</td></tr></table>

parse/train/BkeStsCcKQ/BkeStsCcKQ.md

@@ -0,0 +1,259 @@
+# CRITICAL LEARNING PERIODS IN DEEP NETWORKS
+
+Alessandro Achille ∗ Department of Computer Science University of California, Los Angeles achille@cs.ucla.edu
+
+Matteo Rovere ∗   
+Ann Romney Center for Neurologic Diseases   
+Brigham and Women’s Hospital and Harvard Medical School   
+mrovere@bwh.harvard.edu
+
+# Stefano Soatto
+
+Department of Computer Science University of California, Los Angeles soatto@cs.ucla.edu
+
+# ABSTRACT
+
+Similar to humans and animals, deep artificial neural networks exhibit critical periods during which a temporary stimulus deficit can impair the development of a skill. The extent of the impairment depends on the onset and length of the deficit window, as in animal models, and on the size of the neural network. Deficits that do not affect low-level statistics, such as vertical flipping of the images, have no lasting effect on performance and can be overcome with further training. To better understand this phenomenon, we use the Fisher Information of the weights to measure the effective connectivity between layers of a network during training. Counterintuitively, information rises rapidly in the early phases of training, and then decreases, preventing redistribution of information resources in a phenomenon we refer to as a loss of “Information Plasticity”. Our analysis suggests that the first few epochs are critical for the creation of strong connections that are optimal relative to the input data distribution. Once such strong connections are created, they do not appear to change during additional training. These findings suggest that the initial learning transient, under-scrutinized compared to asymptotic behavior, plays a key role in determining the outcome of the training process. Our findings, combined with recent theoretical results in the literature, also suggest that forgetting (decrease of information in the weights) is critical to achieving invariance and disentanglement in representation learning. Finally, critical periods are not restricted to biological systems, but can emerge naturally in learning systems, whether biological or artificial, due to fundamental constrains arising from learning dynamics and information processing.
+
+# 1 INTRODUCTION
+
+Critical periods are time windows of early post-natal development during which sensory deficits can lead to permanent skill impairment (Kandel et al., 2013). Researchers have documented critical periods affecting a range of species and systems, from visual acuity in kittens (Wiesel & Hubel, 1963b; Wiesel, 1982) to song learning in birds (Konishi, 1985). Uncorrected eye defects (e.g., strabismus, cataracts) during the critical period for visual development lead to amblyopia in one in fifty adults.
+
+The cause of critical periods is ascribed to the biochemical modulation of windows of neuronal plasticity (Hensch, 2004). In this paper, however, we show that deep neural networks (DNNs), while completely devoid of such regulations, respond to sensory deficits in ways similar to those observed in humans and animal models. This surprising result suggests that critical periods may arise from information processing, rather than biochemical, phenomena.
+
+We propose using the information in the weights, measured by an efficient approximation of the Fisher Information, to study critical period phenomena in DNNs. We show that, counterintuitively, the information in the weights does not increase monotonically during training. Instead, a rapid growth in information (“memorization phase”) is followed by a reduction of information (“reorganization” or “forgetting” phase), even as classification performance keeps increasing. This behavior is consistent across different tasks and network architectures. Critical periods are centered in the memorization phase.
+
+![](images/bc9304fdee2c82ef30b5289c45a25326a100eb14cc72ac66532c6b07178c25b9.jpg)  
+Figure 1: Final accuracy achieved by a CNN trained with acritical period for this deficit in the ANN: if the blur is not removed within tFigure 1: DNNs exhibit critical periods. (A) Final accuracy achieved by a CNN trained with final performance is sa cataract-like deficit as a function of the training epoch $N$ rely decreased when compared to the baseline (fromat which the deficit is removed (solid Performance is permanently impaired if the deficit is not corrected early enough, regardless of howabsence of a deficit, to more than 18% when the blur is present over 140 epochline). Performance is permanently impaired if the deficit is not corrected early enough, regardless The profile of the curve is also strikingly similar to the one obtained in kittensof how much additional training is performed. As in animal models, critical periods coincide with learning phase during which test accuracy would rapidly increase in the absence of deficits (dashed).from near birth and whose visual acuity upon eye-opening was tested and ploof the deficit window (Mitchell, 1988). Just like in humans and animal mthe early learning phase during which, in the absence of deficits, test accuracy would rapidly inFor comparison, we report acuity for kittens monocularly deprived since birth and tested at theperiods are characteristic of early development), the critical period in the Dcrease (dashed). (B) For comparison, we report acuity for kittens monocularly deprived since birth time of eye-opening (solid), and normal development visual acuity in kittens as a function of agethe initial rapid learning phase. At this stage, the network is quickly learningand tested at the time of eye-opening (solid), and normal visual acuity development (in kittens) (dashed) (Giffin & Mitchell, 1978; Mitchell, 1988).test error plateaus and the longer asymptotic convergence phase begins.as a function of their age (dashed) (Giffin & Mitchell, 1978; Mitchell, 1988). Sensitivity during Sensitivity to deficit. To quantify more accurately the sensitivity of the Alearning: (C) Final test accuracy of a DNN as a function of the onset of a short 40-epoch deficit. throughout its early learning phase, we introduced the deficit in a short constanThe decrease in the final performance can be used to measure the sensitivity to deficits. The most artificial neural networks (ANNs) are only loosely inspired by biological systems (Hassabis et al.,starting at different epochs, and then measured the decrease in the ANN’s fisensitive epochs corresponds to the early rapid learning phase, before the test error (dashed line) 2017).               onset of the deficit. We observe that the network’s sensitivity to blurring peakbegins to plateau. Afterwards, the network is largely unaffected by the temporary deficit. (D) This the early rapid learning phase (around 30 epochs), while later deficits produccan be compared with changes in the degree of functional disconnection (normalized numbers of Most studies to date have focused either on the behavior of networks at convergence (Representationsimilar experiment was also performed on kittens by Olson and Freeman, usiV1 monocular cells disconnected from the contralateral eye) as a function of the kittens’ age at the Learning) or on the asymptotic properties of the numerical scheme used to get there (Optimization).            onset of a 10-12-day deficit window (Olson & Freeman, 1980). Dashed lines are as in A and B The role of the initial transient, especially itrespectively, up to a re-scaling of the y-axis.
+
+1 We employed this method, instead of a simpler Gaussian blur, since it has a veryOur findings, described in Section 2, indicate that the early transient is critical in determining the the quantification of information loss clearer.final solution of the optimization associated with training an artificial neural network. In particular, the effects of sensory deficits during a critical period cannot be overcome, no matter how much 3additional training is performed. Yet most theoretical studies have focused on the network behavior In animals, sensory deficits introduced during critical periods induce changes in the architectureafter convergence (Representation Learning) or on the asymptotic properties of the optimization of the corresponding areas (Dascheme used for training (SGD).
+
+the weights of the network as a proxy to measure its “effective connectivity”, that is, the density ofTo study this early phase, in Section 3, we use the Fisher Information to quantify the effective connections that are effectively used by the network in order to solve the task. Like others before usconnectivity of a network during training, and introduce the notion of Information Plasticity in (Shwartz-Ziv & Tishby, 2017), we observe two distinct phases during the training, first a “learninglearning. Information Plasticity is maximal during the memorization phase, and decreases in the phase” in which the Fisher Information of the weights increases as the network learns from the data,reorganization phase. We show that deficit sensitivity during critical periods correlates strongly followed by a “consolidation”with the effective connectivity.
+
+and stabilizes. Sensitivity to critical-period-inducing deficits is maximal exactly when the FisherIn Section 4 we discuss our contribution in relation to previous work. When considered in conjuncInformation peaks.tion with recent results on representation learning (Achille & Soatto, 2018), our findings indicate A layer-wise analysis of the network’s effective connectivity shows that, in the tasks and deficitsthat forgetting (reducing information in the weights) is critical to achieving invariance to nuisance we consider, the hierarchy of low-level and high-level features in the training data is a key aspectvariability as well as independence of the components of the representation, but comes at the price of behind the observed phenomena. In particular, our experiments suggest that the existence of criticalreduced adaptability later in the training. We also hypothesize that the loss of physical connectivity periods in deep neural networks depends on the inability of the network to change its effectivein biology (neural plasticity) could be a consequence, rather than a cause, of the loss of Informaconnectivity pattern in order to process different information (in response to deficit removal). Wetion Plasticity, which depends on how the information is distributed throughout a network during call this phenomenon, which is not mediated by any external factors, a loss of the “Informationthe early stages of learning. These results also shed light on the common practice of pre-training Plasticity” of the network.a model on a task and then fine-tune it for another, one of the most rudimentary forms of transfer learning. Our experiments show that, rather than helpful, pre-training can be detrimental, even if the tasks are similar (e.g., same labels, slightly blurred images).
+
+# 3 DEEP ARTIFIC2 EXPERIMENTS
+
+A notable example of critical period-inducing deficit, which also commonly affects humans, is am-A notable example of critical period-related deficit, commonly affecting humans, is amblyopia (reblyopia (reduced visual acuity in one eye) caused unilateral cataracts during infancy or childhoodduced visual acuity in one eye) caused by cataracts during infancy or childhood (Taylor et al., 1979;
+
+![](images/00b00d7863e7d524167c46a58eb25a4f054fb0ee18ad8940fe57666f4d3a1680.jpg)  
+Figure 2: (Left) High-level perturbations do not induce a critical period. When the deficit only affects high-level features (vertical flip of the image) or the last layer of the CNN (label permutation), the network does not exhibit critical periods (test accuracy remains largely flat). On the other hand, a sensory deprivation-like deficit (image is replaced by random noise) does cause a deficit, but the effect is less severe than in the case of image blur. (Right) Dependence of the critical period profile on the network’s depth. Adding more convolutional layers increases the effect of the deficit during its critical period (shown here is the decrease in test accuracy due to the deficit with respect to the test accuracy reached without deficits).
+
+von Noorden, 1981). Even after surgical correction of cataracts, the ability of the patients to regain normal acuity in the affected eye depends both on the duration of the deficit and on its age of onset, with earlier and longer deficits causing more severe effects. In this section, we aim to study the effects of similar deficits in DNNs. To do so, we train a standard All-CNN architecture based on Springenberg et al. (2014) (see Appendix A) to classify objects in small $3 2 \times 3 2$ images from the CIFAR-10 dataset (Krizhevsky & Hinton, 2009). We train with SGD using an exponential annealing schedule for the learning rate. To simulate the effect of cataracts, for the first $t _ { 0 }$ epochs the images in the dataset are downsampled to $8 \times 8$ and then upsampled back to $3 2 \times 3 2$ using bilinear interpolation, in practice blurring the image and destroying small-scale details.1 After that, the training continues for 160 more epochs, giving the network time to converge and ensuring it is exposed to the same number of uncorrupted images as in the control $t _ { 0 } = 0$ ) experiment.
+
+DNNs exhibit critical periods: In Figure 1, we plot the final performance of a network affected by the deficit as a function of the epoch $t _ { 0 }$ at which the deficit is corrected. We can readily observe the existence of a critical period: If the blur is not removed within the first 40-60 epochs, the final performance is severely decreased when compared to the baseline (up to a threefold increase in error). The decrease in performance follows trends commonly observed in animals, and may be qualitatively compared, for example, to the loss of visual acuity observed in kittens monocularly deprived from birth as a function of the length of the deficit (Mitchell, 1988).2
+
+We can measure more accurately the sensitivity to a blur deficit during learning by introducing the deficit in a short window of constant length (40 epochs), starting at different epochs, and then measure the decrease in the DNN’s final performance compared to the baseline (Figure 1). Doing this, we observe that the sensitivity to the deficit peaks in the central part of the early rapid learning phase (at around 30 epochs), while introducing the deficit later produces little or no effect. A similar experiment performed on kittens, using a window of 10-12 days during which the animals are monocularly deprived, again shows a remarkable similarity between the profiles of the sensitivity curves (Olson & Freeman, 1980).
+
+High-level deficits are not associated with a critical period: A natural question is whether any change in the input data distribution will have a corresponding critical period for learning. This is not the case for neuronal networks, which remain plastic enough to adapt to high-level changes in sensory processing (Daw, 2014). For example, it is well-reported that even adult humans can rapidly adapt to certain drastic changes, such as the inversion of the visual field (Stratton, 1896; Kohler, 1964). In Figure 2, we observe that DNNs are also largely unaffected by high-level deficits – such as vertical flipping of the image, or random permutation of the output labels: After deficit correction, the network quickly recovers its baseline performance. This hints at a finer interplay between the structure of the data distribution and the optimization algorithm, resulting in the existence of a critical period.
+
+![](images/660e0e61644dd32c7fc44810bd7f264b523bb08dd7ee31b4bf11198c592fbc9c.jpg)  
+Figure 3: Critical periods in different DNN architectures and optimization schemes. (Left) Effect of an image blur deficit in a ResNet architecture trained on CIFAR-10 with learning rate annealing and (Center) in a deep fully-connected network trained on MNIST with a fixed learning rate. Different architectures, using different optimization methods and trained on different datasets, still exhibit qualitatively similar critical period behavior. (Right) Same experiment as in Figure 1, but using a fixed learning rate instead of an annealing scheme. Although the time scale of the critical period is longer, the trends are similar, supporting the notion that critical periods cannot be explained solely in terms of the loss landscape of the optimization. (Bottom Left) Networks trained without weight decay have shorter and sharper critical periods. Gradually increasing the weight decay makes the critical period longer, until the point where it stops training properly. (Bottom Right) Using a different optimization method (Adam) we observe a similar behavior to standard SGD.
+
+Sensory deprivation: We now apply to the network a more drastic deficit, where each image is replaced by white noise. Figure 2 shows hows this extreme deficit exhibits a remarkably less severe effect than the one obtained by only blurring images: Training the network with white noise does not provide any information on the natural images, and results in milder effects than those caused by a deficit (e.g., image blur), which instead conveys some information, but leads the network to (incorrectly) learn that no fine structure is present in the images. A similar effect has been observed in animals, where a period of early sensory deprivation (dark-rearing) can lengthen the critical period and thus cause less severe effects than those documented in light-reared animals (Mower, 1991). We refer the reader to Appendix C for a more detailed comparison between sensory deprivation and training on white noise.
+
+Architecture, depth, and learning rate annealing: Figure 3 shows that a fully-connected network trained on the MNIST digit classification dataset also shows a critical period for the image blur deficit. Therefore, the convolutional structure is not necessary, nor is the use of natural images. Similarly, a ResNet-18 trained on CIFAR-10 also has a critical period, which is also remarkably sharper than the one found in a standard convolutional network (Figure 1). This is especially interesting, since ResNets allow for easier backpropagation of gradients to the lower layers, thus suggesting that the critical period is not caused by vanishing gradients. However, Figure 2 (Right) shows that the presence of a critical period does indeed depend critically on the depth of the network. In Figure 3, we confirm that a critical period exists even when the network is trained with a constant learning rate, and therefore cannot be explained by an annealed learning rate in later epochs.
+
+Optimization method and weight decay: Figure 3 (Bottom Right) shows that when using Adam as the optimization scheme, which renormalizes the gradients using a running mean of their first two moments, we still observe a critical period similar to that of standard SGD. However, changing the hyperparameters of the optimization can change the shape of the critical period: In Figure 3 (Bottom Left) we show that increasing weight decay makes critical periods longer and less sharp. This can be explained as it both slows the convergence of the network, and it limits the ability of higher layers to change to overcome the deficit, thus encouraging lower layers to also learn new features.
+
+![](images/8fd14e4f6cfa6c6727f089276be690cb67054a32edc04eeafeffa56fca6da7f3.jpg)  
+Figure 4: Critical periods in DNNs are traced back to changes in the Fisher Information. (Left) Trace of the Fisher Information of the network weights as a function of the training epoch (blue line), showing two distinct phases of training: First, information sharply increases, but once test performance starts to plateau (green line), the information in the weights decreases during a “consolidation” phase. Eventually less information is stored, yet test accuracy improves slightly (green line). The weights’ Fisher Information correlates strongly with the networks sensitivity to critical periods, computed as in Figure 1 using both a window size of 40 and 60, and fitted here to the Fisher Information using a simple exponential fit. (Center) Recalling the connection between FIM ad connectivity, we may compare it to synaptic density during development in the visual cortex of macaques (Rakic et al., 1986). Here too, a rapid increase in connectivity is followed by elimination of synapses (pruning) continuing throughout life. (Right) Effects of critical period-inducing blurring on the Fisher Information: The impaired network uses more information to solve the task, compared to training in the absence of a deficit, since it is forced to memorize the labels case by case.
+
+# 3 FISHER INFORMATION ANALYSIS
+
+We have established empirically that, in animals and DNNs alike, the initial phases of training are critical to the outcome of the training process. In animals, this strongly relates to changes in the brain architecture of the areas associated with the deficit (Daw, 2014). This is inevitably different in artificial networks, since their connectivity is formally fixed at all times during training. However, not all the connections are equally useful to the network: Consider a network encoding the approximate posterior distribution $p _ { w } ( y | x )$ , parameterized by the weights $w$ , of the task variable $y$ given an input image $x$ . The dependency of the final output from a specific connection can be estimated by perturbing the corresponding weight and looking at the magnitude of the change in the final distribution. Specifically, given a perturbation $w ^ { \prime } = w + \delta w$ of the weights, the discrepancy between the $p _ { w } ( y | x )$ and the perturbed network output $p _ { w ^ { \prime } } ( y | x )$ can be measured by their KullbackLeibler divergence, which, to second-order approximation, is given by:
+
+$$
+\begin{array} { r } { \mathbb { E } _ { x } \operatorname { K L } \big ( p _ { w ^ { \prime } } ( y | x ) \| p _ { w } ( y | x ) \big ) = \delta w \cdot F \delta w + o ( \delta w ^ { 2 } ) , } \end{array}
+$$
+
+where the expectation over $x$ is computed using the empirical data distribution $\hat { Q } ( x )$ given by the dataset, and
+
+$$
+F : = \mathbb { E } _ { x \sim \hat { Q } ( x ) } \mathbb { E } _ { y \sim p _ { w } ( y | x ) } [ \nabla _ { w } \log p _ { w } ( y | x ) \nabla _ { w } \log p _ { w } ( y | x ) ^ { T } ]
+$$
+
+is the Fisher Information Matrix (FIM). The FIM can thus be considered a local metric measuring how much the perturbation of a single weight (or a combination of weights) affects the output of the network (Amari $\&$ Nagaoka, 2000). In particular, weights with low Fisher Information can be changed or “pruned” with little effect on the network’s performance. This suggests that the Fisher Information can be used as a measure of the effective connectivity of a DNN, or, more generally, of the “synaptic strength” of a connection (Kirkpatrick et al., 2017). Finally, the FIM is also a semidefinite approximation of the Hessian of the loss function (Martens, 2014) and hence of the curvature of the loss landscape at a particular point $w$ during training, providing an elegant connection between the FIM and the optimization procedure (Amari & Nagaoka, 2000), which we will also employ later.
+
+Unfortunately, the full FIM is too large to compute. Rather, we use its trace to measure the global or layer-wise connection strength, which we can compute efficiently using (Appendix A):
+
+$$
+\mathrm { t r } ( F ) = \mathbb { E } _ { \boldsymbol { x } \sim \hat { Q } ( \boldsymbol { x } ) } \mathbb { E } _ { \boldsymbol { y } \sim p _ { w } ( \boldsymbol { y } \vert \boldsymbol { x } ) } [ \Vert \nabla _ { w } \log p _ { w } ( \boldsymbol { y } \vert \boldsymbol { x } ) \Vert ^ { 2 } ] .
+$$
+
+In order to capture the behavior of the off-diagonal terms, we also tried computing the logdeterminant of the full matrix using the Kronecker-Factorized approximation of Martens & Grosse (2015), but we observed the same qualitative trend as the trace. Since the FIM is a local measure, it is very sensitive to the irregularities of the loss landscape. Therefore, in this section we mainly use ResNets, which have a relatively smooth landscape (Li et al., 2018). For other architectures we use instead a more robust estimator of the FIM based on the injection of noise in the weights (Achille & Soatto, 2018), also described in Appendix A.
+
+Two phases of learning: As its name suggests, the FIM can be thought as a measure of the quantity of information about the training data that is contained in the model (Fisher, 1925). Based on this, one would expect the overall strength of the connections to increase monotonically as we acquire information from experience. However, this is not the case: While during an initial phase the network acquires information about the data, which results in a large increase in the strength of the connections, once the performance in the task begins to plateau, the network starts decreasing the overall strength of its connections. However, this does not correspond to a reduction in performance, rather, performance keeps slowly improving. This can be seen as a “forgetting, or “compression” phase, during which redundant connections are eliminated and non-relevant variability in the data is discarded. It is well-established how the elimination (“pruning”) of unnecessary synapses is a fundamental process during learning and brain development (Rakic et al., 1986) (Figure 4, Center); in Figure 4 (Left) an analogous phenomenon is clearly and quantitatively shown for DNNs.
+
+Strikingly, these changes in the connection strength are closely related to the sensitivity to criticalperiod-inducing deficits such as image blur, computed using the “sliding window” method as in Figure 1. In Figure 4 we see that the sensitivity closely follows the trend of the FIM. This is remarkable since the FIM is a local quantity computed at a single point during the training of a network in the absence of deficit, while sensitivity during a critical period is computed, using test data, at the end of the impaired network training. Figure 4 (Right) further emphasizes the effect of deficits on the FIM: in the presence of a deficit, the FIM grows and remains substantially higher even after the deficit is removed. This may be attributed to the fact that, when the data are so corrupted that classification is impossible, the network is forced to memorize the labels, therefore increasing the quantity of information needed to perform the same task.
+
+Layer-wise effects of deficits: A layer-wise analysis of the FIM sheds further light on how the deficit affects the network. When the network (in this case All-CNN, which has a clearer division among layers than ResNet) is trained without deficits, the most important connections are in the intermediate layers (Figure 5, Left), which can process the input CIFAR-10 image at the most informative intermediate scale. However, if the network is initially trained on blurred data (Figure 5, top right), the strength of the connections is dominated by the top layer (Layer 6). This is to be expected, since the low-level and mid-level structures of the images are destroyed, making the lower layers ineffective. However, if the deficit is removed early in the training (Figure 5, top center), the network manages to “reorganize”, reducing the information contained in the last layer, and, at the same time, increasing the information in the intermediate layers. We refer to these phenomena as changes in “Information Plasticity”. If, however, the data change occurs after the consolidation phase, the network is unable to change its effective connectivity: The connection strength of each layer remains substantially constant. The network has lost its Information Plasticity and is past its critical period.
+
+Critical periods as bottleneck crossings: The analysis of the FIM also sheds light on the geometry of the loss function and the learning dynamics. Since the FIM can be interpreted as the local curvature of the residual landscape, Fig. 4 shows that learning entails crossing bottlenecks: In the initial phase the network enters regions of high curvature (high Fisher Information), and once consolidation begins, the curvature decreases, allowing it to cross the bottleneck and enter the valley below. If the statistics change after crossing the bottleneck, the network is trapped. In this interpretation, the early phases of convergence are critical in leading the network towards the “right” final valley. The end of critical periods comes after the network has crossed all bottlenecks (and thus learned the features) and entered a wide valley (region of the weight space with low curvature, or low Fisher Information).
+
+![](images/27672e0cea4143362994d26d892692368ca07dbec1e4ecad3dc5ce7e4237fa85.jpg)  
+Figure 5: Normalized quantity of information contained in the weights of each layer as a function of the training epoch. (Top Left) In the absence of deficits, the network relies mostly on the middle layers (3-4-5) to solve the task. (Top Right) In the presence of an image blur deficit until epoch 100, more resources are allocated to the higher layers (6-7) rather than to the middle layers. The blur deficit destroys low- and mid-level features processed by those layers, leaving only the global features of the image, which are processed by the higher layers. Even if the deficit is removed, the middle layers remain underdeveloped. (Top Center) When the deficit is removed at an earlier epoch, the layers can partially reconfigure (notice, e.g., the fast loss of information of layer 6), resulting in less severe long-term consequences. We refer to the redistribution of information and the relative changes in effective connectivity as “Information Plasticity”. (Bottom row) Same plots, but using a vertical flip deficit, which does not induce a critical period. As expected, the quantity of information in the layers is not affected.
+
+# 4 DISCUSSION AND RELATED WORK
+
+Critical periods have thus far been considered an exclusively biological phenomenon. At the same time, the analysis of DNNs has focused on asymptotic properties and neglected the initial transient behavior. To the best of our knowledge, we are the first to show that artificial neural networks exhibit critical period phenomena, and to highlight the critical role of the transient in determining the asymptotic performance of the network. Inspired by the role of synaptic connectivity in modulating critical periods, we introduce the use of Fisher Information to study this initial phase. We show that the initial sensitivity to deficits closely follows changes in the FIM, both global, as the network first rapidly increases and then decreases the amount of stored information, and layer-wise, as the network “reorganizes” its effective connectivity in order to optimally process information.
+
+Our work naturally relates to the extensive literature on critical periods in biology. Despite artificial networks being an extremely reductionist approximation of neuronal networks, they exhibit behaviors that are qualitatively similar to the critical periods observed in human and animal models. Our information analysis shows that the initial rapid memorization phase is followed by a loss of Information Plasticity which, counterintuitively, further improves the performance. On the other hand, when combined with the analysis of Achille & Soatto (2018) this suggests that a “forgetting” phase may be desirable, or even necessary, in order to learn robust, nuisance-invariant representations.
+
+The existence of two distinct phases of training has been observed and discussed by Shwartz-Ziv & Tishby (2017), although their analysis builds on the (Shannon) information of the activations, rather than the (Fisher) information in the weights. On a multi-layer perceptron (MLP), Shwartz-Ziv & Tishby (2017) empirically link the two phases to a sudden increase in the gradients’ covariance. It may be tempting to compare these results with our Fisher Information analysis. However, it must be noted that the FIM is computed using the gradients with respect to the model prediction, not to the ground truth label, leading to important qualitative differences. In Figure 6, we show that the covariance and norm of the gradients exhibit no clear trends during training with and without deficits, and, therefore, unlike the FIM, do not correlate with the sensitivity to critical periods. However, a connection between our FIM analysis and the information in the activations can be established based on the work of Achille & Soatto (2018), which shows that the FIM of the weights can be used to bound the information in the activations. In fact, we may intuitively expect that pruning of connections naturally leads to loss of information in the corresponding activations. Thus, our analysis corroborates and expands on some of the claims of Shwartz-Ziv & Tishby (2017), while using an independent framework.
+
+Aside from being more closely related to the deficit sensitivity during critical periods, Fisher’s Information also has a number of technical advantages: Its diagonal is simple to estimate, even on modern state-of-the-art architectures and compelling datasets, and it is less sensitive to the choice estimator of mutual information, avoiding some of the common criticisms to the use of information quantities in the analysis of deep learning models. Finally, the FIM allows us to probe fine changes in the effective connectivity across the layers of the network (Figure 5), which are not visible in Shwartz-Ziv & Tishby (2017).
+
+A complete analysis of the activations should account not only for the amount of information (both task- and nuisance-related), but also for its accessibility, e.g., how easily task-related information can be extracted by a linear classifier. Following a similar idea, Montavon et al. (2011) aim to study the layer-wise, or “spatial” (but not temporal) evolution of the simplicity of the representation by performing a principal component analysis (PCA) of a radial basis function (RBF) kernel embedding of each layer representation. They show that, on a multi-layer perceptron, task-relevant information increasingly concentrate on the first principal components of the representation’s embedding, implying that they become more easily “accessible” layer after layer, while nuisance information (when it is codified at all) is encoded in the remaining components. In our work we instead focus on the temporal evolution of the weights. However, it’s important to notice that a network with simpler weights (as measured by the FIM) also requires a simpler smooth representation (as measured, e.g., by the RBF embedding) in order to operate properly, since it needs to be resistant to perturbations of the weights. Thus our analysis is wholly compatible with the intuitions of Montavon et al. (2011). It would also be interesting to study the joint spatio-temporal evolution of the network using both frameworks at once.
+
+One advantage of focusing on the information of the weights rather than on the activations, or behavior of the network, is to have a readout of the “effective connectivity” during critical periods, which can be compared to similar readouts in animals. In fact, “behavioral” readouts upon deficit removal, both in artificial and neuronal networks, can potentially be confounded by deficit-coping changes at different levels of the visual pathways (Daw, 2014; Knudsen, 2004). On the other hand, deficits in deprived animals are mirrored by abnormalities in the circuitry of the visual pathways, which we characterize in DNNs using the FIM to study its “effective connectivity”, i.e., the connections that are actually employed by the network to solve the task. Sensitivity to critical periods and the trace of the Fisher Information peak at the same epochs, in accord with the evidence that skill development and critical periods in neuronal networks are modulated by changes (generally experience-dependent) in synaptic plasticity (Knudsen, 2004; Hensch, 2004). Our layer-wise analysis of the Fisher Information (Figure 5) also shows that visual deficits reinforce higher layers to the detriment of intermediate layers, leaving low-level layers virtually untouched. If the deficit is removed after the critical period ends, the network is not able to reverse these effects. Although the two systems are radically different, a similar response can be found in the visual pathways of animal models: Lower levels (e.g., retina, lateral geniculate nucleus) and higher-level visual areas (e.g., V2 and post-V2) show little remodeling upon deprivation, while most changes happen in different layers of V1 (Wiesel & Hubel, 1963a; Hendrickson et al., 1987).
+
+An insightful interpretation of critical periods in animal models was proposed by Knudsen (2004): The initial connections of neuronal networks are unstable and easily modified (highly plastic), but as more “samples” are observed, they change and reach a more stable configuration which is difficult to modify. Learning can, however, still happen within the newly created connectivity pattern. This is largely compatible with our findings: Sensitivity to critical-period-inducing deficits peaks when connections are remodeled (Figure 4, Left), and different connectivity profiles are observed in networks trained with and without a deficit (Figure 5). Moreover, high-level deficits such as imageflipping and label permutation, which do not require restructuring of the network’s connections in order to be corrected, do not exhibit a critical period.
+
+Applying a deficit at the beginning of the training may be compared to the common practice of pretraining, which is generally found to improve the performance of the network. Erhan et al. (2010) study the somewhat related, but now seldom used, practice of layer-wise unsupervised pre-training, and suggest that it may act as a regularizer by moving the weights of the network towards an area of the loss landscape closer to the attractors for good solutions, and that early examples have a stronger effect in steering the network towards particular solutions. Here, we have shown that pre-training on blurred data can have the opposite effect; i.e., it can severely decrease the final performance of the network. However, in our case, interpreting the deficits effect as moving the network close to a bad attractor is difficult to reconcile with the smooth transition observed in the critical periods, since the network would either converge to this attractor, and thus have low accuracy, or escape completely.
+
+Instead, we reconcile our experiments with the geometry of the loss function by introducing a different explanation based on the interpretation of the FIM as an approximation of the local curvature. Figure 4 suggests that SGD encounters two different phases during the network training: At first, the network moves towards high-curvature regions of the loss landscape, while in the second phase the curvature decreases and the network eventually converges to a flat minimum (as observed in Keskar et al. (2017)). We can interpret these as the network crossing narrow bottlenecks during its training in order to learn useful features, before eventually entering a flat region of the loss surface once learning is completed and ending up trapped there. When combining this assumption with our deficit sensitivity analysis, we can hypothesize that the critical period occurs precisely upon crossing of this bottleneck. It is also worth noticing how there is evidence that convergence to flat minima (minima with low curvature) in a DNN correlates with a good generalization performance (Hochreiter & Schmidhuber, 1997; Li et al., 2018; Chaudhari et al., 2017; Keskar et al., 2017). Indeed, using this interpretation, Figure 4 (Right) tells us that networks more affected by the deficit converge to sharper minima. However, we have also found that the performance of the network is already mostly determined during the early “sensitive” phase. The final sharpness at convergence may therefore be an epiphenomenon, rather than the cause of good generalization.
+
+# 5 CONCLUSION
+
+Our goal in this paper is not so much to investigate the human (or animal) brain through artificial networks, as to understand fundamental information processing phenomena, both in their biological or artificial implementations. It is also not our goal to suggest that, since they both exhibit critical periods, DNNs are necessarily a valid model of neurobiological information processing, although recent work has emphasized this aspect. We engage in an “Artificial Neuroscience” exercise in part to address a technological need to develop “explainable” artificial intelligence systems whose behavior can be understood and predicted. While traditionally well-understood mathematical models were used by neuroscientists to study biological phenomena, information processing in modern artificial networks is often just as poorly understood as in biology, so we chose to exploit well-known biological phenomena as probes to study information processing in artificial networks.
+
+Conversely, it would also be interesting to explore ways to test whether biological networks prune connections as a consequences of a loss of Information Plasticity, rather than as a cause. The mechanisms underlying network reconfiguration during learning and development might be an evolutionary outcome obtained under the pressure of fundamental information processing phenomena.
+
+# ACKNOWLEDGEMENTS
+
+We thank the anonymous reviewers for their thoughtful feedback, and for suggesting new experiments and relevant literature. Supported by ONR N00014-17-1-2072, ARO W911NF-17-1-0304, AFOSR FA9550-15-1-0229 and FA8650-11-1-7156.
+
+# REFERENCES
+
+Alessandro Achille and Stefano Soatto. Emergence of invariance and disentanglement in deep representations. Journal of Machine Learning Research, 19(1):1947–1980, 2018.
+
+Shun-ichi Amari and Hiroshi Nagaoka. Methods of information geometry, volume 191 of Translations of Mathematical Monographs. American Mathematical Society and Oxford University Press, 2000.
+
+Martin S Banks, Richard N Aslin, and Robert D Letson. Sensitive period for the development of human binocular vision. Science, 190(4215):675–677, 1975.
+
+Pratik Chaudhari, Anna Choromanska, Stefano Soatto, Yann LeCun, Carlo Baldassi, Christian Borgs, Jennifer Chayes, Levent Sagun, and Riccardo Zecchina. Entropy-sgd: Biasing gradient descent into wide valleys. In Proceedings of the International Conference on Learning Representations, 2017.
+
+Nigel W Daw. Visual Development. Springer, New York, NY, 3rd edition, 2014.
+
+Dumitru Erhan, Yoshua Bengio, Aaron Courville, Pierre-Antoine Manzagol, Pascal Vincent, and Samy Bengio. Why does unsupervised pre-training help deep learning? Journal of Machine Learning Research, 11(Feb):625–660, 2010.
+
+Ronald Aylmer Fisher. Theory of statistical estimation. In Mathematical Proceedings of the Cambridge Philosophical Society, volume 22, pp. 700–725. Cambridge University Press, 1925.
+
+Fred Giffin and Donald E Mitchell. The rate of recovery of vision after early monocular deprivation in kittens. The Journal of Physiology, 274(1):511–537, 1978.
+
+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.
+
+Anita E Hendrickson, JA Movshon, Howard M Eggers, Martin S Gizzi, RG Boothe, and Lynne Kiorpes. Effects of early unilateral blur on the macaque’s visual system. ii. anatomical observations. Journal of Neuroscience, 7(5):1327–1339, 1987.
+
+Takao K Hensch. Critical period regulation. Annuual review of neuroscience, 27:549–579, 2004.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Flat minima. ¨ Neural Computation, 9(1):1–42, 1997.
+
+Eric R Kandel, James H Schwartz, Thomas M Jessell, Steven A Siegelbaum, and A James Hudspeth. Principles of Neural Science. McGraw-Hill, New York, NY, 5th edition, 2013.
+
+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. In Proceedings of the International Conference on Learning Representations, 2017.
+
+Durk P Kingma, Tim Salimans, and Max Welling. Variational dropout and the local reparameterization trick. In Advances in Neural Information Processing Systems, pp. 2575–2583, 2015.
+
+James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al. Overcoming catastrophic forgetting in neural networks. Proceedings of the national academy of sciences, 114(13):3521–3526, 2017.
+
+Eric I Knudsen. Sensitive periods in the development of the brain and behavior. Journal of cognitive neuroscience, 16(8):1412–1425, 2004.
+
+Ivo Kohler. The formation and transformation of the perceptual world. Psychological Issues Monographs. International Universities Press, Inc., New York, NY, 1964.
+
+Masakazu Konishi. Birdsong: from behavior to neuron. Annual review of neuroscience, 8(1):125– 170, 1985.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, University of Toronto, 2009.
+
+Hao Li, Zheng Xu, Gavin Taylor, Christoph Studer, and Tom Goldstein. Visualizing the loss landscape of neural nets. In Advances in Neural Information Processing Systems, pp. 6391–6401, 2018.
+
+James Martens. New insights and perspectives on the natural gradient method. arXiv preprint arXiv:1412.1193, 2014.
+
+James Martens and Roger Grosse. Optimizing neural networks with kronecker-factored approximate curvature. Proceedings of International Conference on Machine Learning, 37:2408–2417, 2015.   
+Donald E Mitchell. The extent of visual recovery from early monocular or binocular visual deprivation in kittens. The Journal of physiology, 395(1):639–660, 1988.   
+Gregoire Montavon, Mikio L Braun, and Klaus-Robert M ´ uller. Kernel analysis of deep networks.¨ Journal of Machine Learning Research, 12(Sep):2563–2581, 2011.   
+George D Mower. The effect of dark rearing on the time course of the critical period in cat visual cortex. Developmental Brain Research, 58(2):151–158, 1991.   
+Carl R Olson and Ralph D Freeman. Profile of the sensitive period for monocular deprivation in kittens. Experimental Brain Research, 39(1):17–21, 1980.   
+Pasko Rakic, Jean-Pierre Bourgeois, Maryellen F Eckenhoff, Nada Zecevic, and Patricia S Goldman-Rakic. Concurrent overproduction of synapses in diverse regions of the primate cerebral cortex. Science, 232(4747):232–235, 1986.   
+Ravid Shwartz-Ziv and Naftali Tishby. Opening the black box of deep neural networks via information. arXiv preprint arXiv:1703.00810, 2017.   
+Jost T Springenberg, Alexey Dosovitskiy, Thomas Brox, and Martin Riedmiller. Striving for simplicity: The all convolutional net. arXiv preprint arXiv:1412.6806, 2014.   
+George M Stratton. Some preliminary experiments on vision without inversion of the retinal image. Psychological Review, 3(6):611–617, 1896.   
+David Taylor et al. Critical period for deprivation amblyopia in children. Transactions of the ophthalmological societies of the United Kingdom, 99(3):432–439, 1979.   
+Gunter K von Noorden. New clinical aspects of stimulus deprivation amblyopia. American journal of ophthalmology, 92(3):416–421, 1981.   
+Torsten N Wiesel. Postnatal development of the visual cortex and the influence of environment. Nature, 299(5884):583, 1982.   
+Torsten N Wiesel and David H Hubel. Single-cell responses in striate cortex of kittens deprived of vision in one eye. Journal of neurophysiology, 26(6):1003–1017, 1963a.   
+Torsten N Wiesel and David H Hubel. Effects of visual deprivation on morphology and physiology of cells in the cat’s lateral geniculate body. Journal of neurophysiology, 26(6):978–993, 1963b.
+
+# A DETAILS OF THE EXPERIMENTS
+
+# A.1 ARCHITECTURES AND TRAINING
+
+In all of the experiments, unless otherwise stated, we use the following All-CNN architecture, adapted from Springenberg et al. (2014):
+
+conv 96 - conv 96 - conv 192 s2 - conv 192 - conv 192 - conv 192 s2 - conv 192 - conv1 192 - conv1 10 - avg. pooling - softmax where each conv block consists of a $3 \times 3$ convolution, batch normalization and ReLU activations. conv1 denotes a $1 \times 1$ convolution. The network is trained with SGD, with a batch size of 128, learning rate starting from 0.05 and decaying smoothly by a factor of .97 at each epoch. We also use weight decay with coefficient 0.001. In the experiments with a fixed learning rate, we fix the learning rate to 0.001, which we find to allow convergence without excessive overfitting. For the ResNet experiments, we use the ResNet-18 architecture from He et al. (2016) with initial learning rate 0.1, learning rate decay .97 per epoch, and weight decay 0.0005. When training with Adam, we use a learning rate of 0.001 and weight decay 0.0001.
+
+When experimenting with varying network depths, we use the following architecture:
+
+In order to avoid interferences between the annealing scheme and the architecture, in these experiments we fix the learning rate to 0.001.
+
+The Fully Connected network used for the MNIST experiments has hidden layers of size [2500, 2000, 1500, 1000, 500]. All hidden layers use batch normalization followed by ReLU activations. We fix the learning rate to 0.005. Weight decay is not used. We use data augmentation with random translations up to 4 pixels and random horizontal flipping. For MNIST, we pad the images with zeros to bring them to size $3 2 \times 3 2$ .
+
+# A.2 APPROXIMATIONS OF THE FISHER INFORMATION MATRIX
+
+To compute the trace of the Fisher Information Matrix, we use the following expression derived directly from the definition:
+
+$$
+\begin{array} { r l } & { \mathrm { t r } ( F ) = \mathbb { E } _ { x \sim \hat { Q } ( x ) } \mathbb { E } _ { y \sim p _ { w } ( y \vert x ) } [ \mathrm { t r } ( \nabla _ { w } \log p _ { w } ( y \vert x ) \nabla _ { w } \log p _ { w } ( y \vert x ) ^ { T } ) ] } \\ & { \quad \quad \quad = \mathbb { E } _ { x \sim \hat { Q } ( x ) } \mathbb { E } _ { y \sim p _ { w } ( y \vert x ) } [ \Vert \nabla _ { w } \log p _ { w } ( y \vert x ) \Vert ^ { 2 } ] , } \end{array}
+$$
+
+where the input image $x$ is sampled from the dataset, while the label $y$ is sampled from the output posterior. Expectations are approximated by Monte-Carlo sampling. Notice, however, that this expression depends only on the local gradients of the loss with respect to the weights at a point $w = w _ { 0 }$ , so it can be noisy when the loss landscape is highly irregular. This is not a problem for ResNets Li et al. (2018), but for other architectures we use instead a different technique, proposed in Achille & Soatto (2018). More in detail, let $L ( w )$ be the standard cross-entropy loss. Given the current weights $w _ { 0 }$ of the network, we find the diagonal matrix $\Sigma$ that minimizes:
+
+$$
+L ^ { \prime } = \mathbb { E } _ { w \sim N ( w _ { 0 } , \Sigma ) } [ L ( w ) ] - \beta \log | \Sigma | ,
+$$
+
+where $\beta$ is a parameter that controls the smoothness of the approximation. Notice that $L ^ { \prime }$ can be minimized efficiently using the method in Kingma et al. (2015). To see how this relates to the Fisher Information Matrix, assume that $L ( w )$ can be approximated locally in $w _ { 0 }$ as $L ( w ) =$ $L _ { 0 } + a \cdot w + w \cdot H w$ . We can then rewrite $L ^ { \prime }$ as
+
+$$
+\begin{array} { r } { L ^ { \prime } = L _ { 0 } + \mathrm { t r } ( \Sigma H ) - \beta \log | \Sigma | . } \end{array}
+$$
+
+Taking the derivative with respect to $\Sigma$ , and setting it to zero, we obtain $\Sigma _ { i i } = \beta / H _ { i i }$ . We can then use $\Sigma$ to estimate the trace of the Hessian, and hence of the Fisher information.
+
+# A.3 CURVE FITTING
+
+Fitting of sensitivity curves and synaptic density profiles from the literature was performed using:
+
+$$
+f ( t ) = \mathrm { e } ^ { - ( t - d ) / \tau _ { 1 } } - k \mathrm { e } ^ { - ( t - d ) / \tau _ { 2 } }
+$$
+
+as the fitting equation, where $t$ is the age at the time of sampling and $\tau _ { 1 } , \tau _ { 2 } , k$ and $d$ are unconstrained parameters (Banks et al., 1975).
+
+The exponential fit of the sensitivity to the Fisher Information trace uses the expression
+
+$$
+F ( t ) = a \exp ( c S _ { k } ( t ) ) + b ,
+$$
+
+where $a$ , $b$ and $c$ are unconstrained parameters, $F ( t )$ is the Fisher Information trace at epoch $t$ of the training of a network without deficits and $S _ { k }$ is the sensitivity computed using a window of size $k$ . That is, $S _ { k } ( t )$ is the increase in the final test error over a baseline when the network is trained in the presence of a deficit between epochs $t$ and $t + k$ .
+
+# B ADDITIONAL PLOTS
+
+![](images/fe0370d7f3e28d3a6eda988bd2abb84484acd8448cfad4dfc312bc5796496c83.jpg)  
+Figure 6: Log of the norm of the gradient means (solid line) and standard deviation (dashed line) during training when: (Left) No deficit is present, (Center) A blur deficit is present until epoch 70, and (Right) a deficit is present until the last epoch. Notice that the presence of a deficit does not decrease the magnitude of the gradients propagated to the first layers during the last epochs, rather it seems to increase it, suggesting that vanishing gradients are not the cause of the critical period for the blurring deficit.
+
+![](images/46f616f0a75dddecb77d81235a32ad0b5eba8f68c46b43b45a7fd7c783e9bb20.jpg)  
+Figure 7: Same plot as in Figure 5, but for a noise deficit. Unlike with blur, much more resources are allocated to the lower-layers rather than higher-layers. This may explain why it is easier for the network to reconfigure to solve the task after the deficit is removed.
+
+![](images/d0ba0320eb6f0fb9cf03b20dd2ca7b2df008720650c0b49932910d7115a007a3.jpg)  
+Figure 8: Visualization of the filters of the first layer of the network used for the experiment in Figure 1. In absence of a deficit, the network learns high-frequency filters, as seen by the fact that many filters are not smooth (first picture). However, when a blurring deficit is present, the network learns only smooth filters corresponding to low-frequencies of the input (third picture). If the deficit is removed after the end of the critical period, the network does not manage to learn high-frequency filters (second picture).
+
+# C EXPERIMENTAL DESIGN AND COMPARISON WITH ANIMAL MODELS
+
+Critical periods are task- and deficit-specific. The specific task we address is visual acuity, but the performance is necessarily measured through different mechanisms in animals and Artificial Neural Networks. In animals, visual acuity is traditionally measured by testing the ability to discriminate between black-and-white contrast gratings (with varying spatial frequency) and a uniform gray field. The outcome of such tests generally correlates well with the ability of the animal to use the eye to solve other visual tasks relying on acuity. Convolutional Neural Networks, on the other hand, have a very different sensory processing mechanism (based on heavily quantized data), which may trivialize such a test. Rather, we directly measure the performance of the network on an high-level task, specifically image classification, for which CNNs are optimized.
+
+We chose to simulate cataracts in our DNN experiments, a deficit which allows us to explore its complex interactions with the structure of the data and the architecture of the network. Unfortunately, while the overall trends of cataract-induced critical periods have been studied and understood in animal models, there is not enough data to confidently regress sensibility curves comparable to those obtained in DNNs. For this reason, in Figure 1 we compare the performance loss in a DNN trained in the presence of a cataract-like deficit with the results obtained from monocularly deprived kittens, which exhibit similar trends and are one of the most common experimental paradigms in the visual neurosciences.
+
+Simulating complete visual deprivation in a neural network is not as simple as feeding a constant stimulus: a network presented with a constant blank input will rapidly become trivial and thus unable to train on new data. This is to be expected, since a blank input is a perfectly predictable stimulus and thus the network can quickly learn the (trivial) solution to the task. We instead wanted to model an uninformative stimulus, akin to noise. Moreover, even when the eyes are sutured or maintained in the darkness, there will be background excitation of photoreceptors that is best modeled as noise. To account for this, we simulate sensory deprivation by replacing the input images with a dataset composed of (uninformative) random Gaussian noise. This way the network is trained on solving the highly non-trivial task of memorizing the association between the finitely-many noise patterns and their corresponding labels.

parse/train/BkeStsCcKQ/BkeStsCcKQ_content_list.json

@@ -0,0 +1,1320 @@
+[
+    {
+        "type": "text",
+        "text": "CRITICAL LEARNING PERIODS IN DEEP NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            98,
+            797,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Alessandro Achille ∗ Department of Computer Science University of California, Los Angeles achille@cs.ucla.edu ",
+        "bbox": [
+            184,
+            145,
+            431,
+            200
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Matteo Rovere ∗   \nAnn Romney Center for Neurologic Diseases   \nBrigham and Women’s Hospital and Harvard Medical School   \nmrovere@bwh.harvard.edu ",
+        "bbox": [
+            449,
+            145,
+            852,
+            200
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Stefano Soatto ",
+        "text_level": 1,
+        "bbox": [
+            184,
+            223,
+            287,
+            236
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Department of Computer Science University of California, Los Angeles soatto@cs.ucla.edu ",
+        "bbox": [
+            184,
+            237,
+            431,
+            277
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            303,
+            544,
+            318
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Similar to humans and animals, deep artificial neural networks exhibit critical periods during which a temporary stimulus deficit can impair the development of a skill. The extent of the impairment depends on the onset and length of the deficit window, as in animal models, and on the size of the neural network. Deficits that do not affect low-level statistics, such as vertical flipping of the images, have no lasting effect on performance and can be overcome with further training. To better understand this phenomenon, we use the Fisher Information of the weights to measure the effective connectivity between layers of a network during training. Counterintuitively, information rises rapidly in the early phases of training, and then decreases, preventing redistribution of information resources in a phenomenon we refer to as a loss of “Information Plasticity”. Our analysis suggests that the first few epochs are critical for the creation of strong connections that are optimal relative to the input data distribution. Once such strong connections are created, they do not appear to change during additional training. These findings suggest that the initial learning transient, under-scrutinized compared to asymptotic behavior, plays a key role in determining the outcome of the training process. Our findings, combined with recent theoretical results in the literature, also suggest that forgetting (decrease of information in the weights) is critical to achieving invariance and disentanglement in representation learning. Finally, critical periods are not restricted to biological systems, but can emerge naturally in learning systems, whether biological or artificial, due to fundamental constrains arising from learning dynamics and information processing. ",
+        "bbox": [
+            233,
+            332,
+            764,
+            583
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            608,
+            336,
+            623
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Critical periods are time windows of early post-natal development during which sensory deficits can lead to permanent skill impairment (Kandel et al., 2013). Researchers have documented critical periods affecting a range of species and systems, from visual acuity in kittens (Wiesel & Hubel, 1963b; Wiesel, 1982) to song learning in birds (Konishi, 1985). Uncorrected eye defects (e.g., strabismus, cataracts) during the critical period for visual development lead to amblyopia in one in fifty adults. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            720
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The cause of critical periods is ascribed to the biochemical modulation of windows of neuronal plasticity (Hensch, 2004). In this paper, however, we show that deep neural networks (DNNs), while completely devoid of such regulations, respond to sensory deficits in ways similar to those observed in humans and animal models. This surprising result suggests that critical periods may arise from information processing, rather than biochemical, phenomena. ",
+        "bbox": [
+            174,
+            728,
+            825,
+            799
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose using the information in the weights, measured by an efficient approximation of the Fisher Information, to study critical period phenomena in DNNs. We show that, counterintuitively, the information in the weights does not increase monotonically during training. Instead, a rapid growth in information (“memorization phase”) is followed by a reduction of information (“reorganization” or “forgetting” phase), even as classification performance keeps increasing. This behavior is consistent across different tasks and network architectures. Critical periods are centered in the memorization phase. ",
+        "bbox": [
+            174,
+            805,
+            825,
+            902
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/bc9304fdee2c82ef30b5289c45a25326a100eb14cc72ac66532c6b07178c25b9.jpg",
+        "image_caption": [
+            "Figure 1: Final accuracy achieved by a CNN trained with acritical period for this deficit in the ANN: if the blur is not removed within tFigure 1: DNNs exhibit critical periods. (A) Final accuracy achieved by a CNN trained with final performance is sa cataract-like deficit as a function of the training epoch $N$ rely decreased when compared to the baseline (fromat which the deficit is removed (solid Performance is permanently impaired if the deficit is not corrected early enough, regardless of howabsence of a deficit, to more than 18% when the blur is present over 140 epochline). Performance is permanently impaired if the deficit is not corrected early enough, regardless The profile of the curve is also strikingly similar to the one obtained in kittensof how much additional training is performed. As in animal models, critical periods coincide with learning phase during which test accuracy would rapidly increase in the absence of deficits (dashed).from near birth and whose visual acuity upon eye-opening was tested and ploof the deficit window (Mitchell, 1988). Just like in humans and animal mthe early learning phase during which, in the absence of deficits, test accuracy would rapidly inFor comparison, we report acuity for kittens monocularly deprived since birth and tested at theperiods are characteristic of early development), the critical period in the Dcrease (dashed). (B) For comparison, we report acuity for kittens monocularly deprived since birth time of eye-opening (solid), and normal development visual acuity in kittens as a function of agethe initial rapid learning phase. At this stage, the network is quickly learningand tested at the time of eye-opening (solid), and normal visual acuity development (in kittens) (dashed) (Giffin & Mitchell, 1978; Mitchell, 1988).test error plateaus and the longer asymptotic convergence phase begins.as a function of their age (dashed) (Giffin & Mitchell, 1978; Mitchell, 1988). Sensitivity during Sensitivity to deficit. To quantify more accurately the sensitivity of the Alearning: (C) Final test accuracy of a DNN as a function of the onset of a short 40-epoch deficit. throughout its early learning phase, we introduced the deficit in a short constanThe decrease in the final performance can be used to measure the sensitivity to deficits. The most artificial neural networks (ANNs) are only loosely inspired by biological systems (Hassabis et al.,starting at different epochs, and then measured the decrease in the ANN’s fisensitive epochs corresponds to the early rapid learning phase, before the test error (dashed line) 2017).               onset of the deficit. We observe that the network’s sensitivity to blurring peakbegins to plateau. Afterwards, the network is largely unaffected by the temporary deficit. (D) This the early rapid learning phase (around 30 epochs), while later deficits produccan be compared with changes in the degree of functional disconnection (normalized numbers of Most studies to date have focused either on the behavior of networks at convergence (Representationsimilar experiment was also performed on kittens by Olson and Freeman, usiV1 monocular cells disconnected from the contralateral eye) as a function of the kittens’ age at the Learning) or on the asymptotic properties of the numerical scheme used to get there (Optimization).            onset of a 10-12-day deficit window (Olson & Freeman, 1980). Dashed lines are as in A and B The role of the initial transient, especially itrespectively, up to a re-scaling of the y-axis. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            98,
+            821,
+            251
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1 We employed this method, instead of a simpler Gaussian blur, since it has a veryOur findings, described in Section 2, indicate that the early transient is critical in determining the the quantification of information loss clearer.final solution of the optimization associated with training an artificial neural network. In particular, the effects of sensory deficits during a critical period cannot be overcome, no matter how much 3additional training is performed. Yet most theoretical studies have focused on the network behavior In animals, sensory deficits introduced during critical periods induce changes in the architectureafter convergence (Representation Learning) or on the asymptotic properties of the optimization of the corresponding areas (Dascheme used for training (SGD). ",
+        "bbox": [
+            174,
+            516,
+            825,
+            601
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "the weights of the network as a proxy to measure its “effective connectivity”, that is, the density ofTo study this early phase, in Section 3, we use the Fisher Information to quantify the effective connections that are effectively used by the network in order to solve the task. Like others before usconnectivity of a network during training, and introduce the notion of Information Plasticity in (Shwartz-Ziv & Tishby, 2017), we observe two distinct phases during the training, first a “learninglearning. Information Plasticity is maximal during the memorization phase, and decreases in the phase” in which the Fisher Information of the weights increases as the network learns from the data,reorganization phase. We show that deficit sensitivity during critical periods correlates strongly followed by a “consolidation”with the effective connectivity. ",
+        "bbox": [
+            174,
+            607,
+            823,
+            678
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "and stabilizes. Sensitivity to critical-period-inducing deficits is maximal exactly when the FisherIn Section 4 we discuss our contribution in relation to previous work. When considered in conjuncInformation peaks.tion with recent results on representation learning (Achille & Soatto, 2018), our findings indicate A layer-wise analysis of the network’s effective connectivity shows that, in the tasks and deficitsthat forgetting (reducing information in the weights) is critical to achieving invariance to nuisance we consider, the hierarchy of low-level and high-level features in the training data is a key aspectvariability as well as independence of the components of the representation, but comes at the price of behind the observed phenomena. In particular, our experiments suggest that the existence of criticalreduced adaptability later in the training. We also hypothesize that the loss of physical connectivity periods in deep neural networks depends on the inability of the network to change its effectivein biology (neural plasticity) could be a consequence, rather than a cause, of the loss of Informaconnectivity pattern in order to process different information (in response to deficit removal). Wetion Plasticity, which depends on how the information is distributed throughout a network during call this phenomenon, which is not mediated by any external factors, a loss of the “Informationthe early stages of learning. These results also shed light on the common practice of pre-training Plasticity” of the network.a model on a task and then fine-tune it for another, one of the most rudimentary forms of transfer learning. Our experiments show that, rather than helpful, pre-training can be detrimental, even if the tasks are similar (e.g., same labels, slightly blurred images). ",
+        "bbox": [
+            174,
+            684,
+            825,
+            837
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 DEEP ARTIFIC2 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            861,
+            326,
+            877
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A notable example of critical period-inducing deficit, which also commonly affects humans, is am-A notable example of critical period-related deficit, commonly affecting humans, is amblyopia (reblyopia (reduced visual acuity in one eye) caused unilateral cataracts during infancy or childhoodduced visual acuity in one eye) caused by cataracts during infancy or childhood (Taylor et al., 1979; ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/00b00d7863e7d524167c46a58eb25a4f054fb0ee18ad8940fe57666f4d3a1680.jpg",
+        "image_caption": [
+            "Figure 2: (Left) High-level perturbations do not induce a critical period. When the deficit only affects high-level features (vertical flip of the image) or the last layer of the CNN (label permutation), the network does not exhibit critical periods (test accuracy remains largely flat). On the other hand, a sensory deprivation-like deficit (image is replaced by random noise) does cause a deficit, but the effect is less severe than in the case of image blur. (Right) Dependence of the critical period profile on the network’s depth. Adding more convolutional layers increases the effect of the deficit during its critical period (shown here is the decrease in test accuracy due to the deficit with respect to the test accuracy reached without deficits). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            228,
+            103,
+            769,
+            220
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "von Noorden, 1981). Even after surgical correction of cataracts, the ability of the patients to regain normal acuity in the affected eye depends both on the duration of the deficit and on its age of onset, with earlier and longer deficits causing more severe effects. In this section, we aim to study the effects of similar deficits in DNNs. To do so, we train a standard All-CNN architecture based on Springenberg et al. (2014) (see Appendix A) to classify objects in small $3 2 \\times 3 2$ images from the CIFAR-10 dataset (Krizhevsky & Hinton, 2009). We train with SGD using an exponential annealing schedule for the learning rate. To simulate the effect of cataracts, for the first $t _ { 0 }$ epochs the images in the dataset are downsampled to $8 \\times 8$ and then upsampled back to $3 2 \\times 3 2$ using bilinear interpolation, in practice blurring the image and destroying small-scale details.1 After that, the training continues for 160 more epochs, giving the network time to converge and ensuring it is exposed to the same number of uncorrupted images as in the control $t _ { 0 } = 0$ ) experiment. ",
+        "bbox": [
+            173,
+            375,
+            825,
+            529
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "DNNs exhibit critical periods: In Figure 1, we plot the final performance of a network affected by the deficit as a function of the epoch $t _ { 0 }$ at which the deficit is corrected. We can readily observe the existence of a critical period: If the blur is not removed within the first 40-60 epochs, the final performance is severely decreased when compared to the baseline (up to a threefold increase in error). The decrease in performance follows trends commonly observed in animals, and may be qualitatively compared, for example, to the loss of visual acuity observed in kittens monocularly deprived from birth as a function of the length of the deficit (Mitchell, 1988).2 ",
+        "bbox": [
+            174,
+            535,
+            825,
+            632
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We can measure more accurately the sensitivity to a blur deficit during learning by introducing the deficit in a short window of constant length (40 epochs), starting at different epochs, and then measure the decrease in the DNN’s final performance compared to the baseline (Figure 1). Doing this, we observe that the sensitivity to the deficit peaks in the central part of the early rapid learning phase (at around 30 epochs), while introducing the deficit later produces little or no effect. A similar experiment performed on kittens, using a window of 10-12 days during which the animals are monocularly deprived, again shows a remarkable similarity between the profiles of the sensitivity curves (Olson & Freeman, 1980). ",
+        "bbox": [
+            174,
+            640,
+            825,
+            751
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "High-level deficits are not associated with a critical period: A natural question is whether any change in the input data distribution will have a corresponding critical period for learning. This is not the case for neuronal networks, which remain plastic enough to adapt to high-level changes in sensory processing (Daw, 2014). For example, it is well-reported that even adult humans can rapidly adapt to certain drastic changes, such as the inversion of the visual field (Stratton, 1896; Kohler, 1964). In Figure 2, we observe that DNNs are also largely unaffected by high-level deficits – such as vertical flipping of the image, or random permutation of the output labels: After deficit correction, the network quickly recovers its baseline performance. This hints at a finer interplay between the structure of the data distribution and the optimization algorithm, resulting in the existence of a critical period. ",
+        "bbox": [
+            174,
+            758,
+            823,
+            869
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/660e0e61644dd32c7fc44810bd7f264b523bb08dd7ee31b4bf11198c592fbc9c.jpg",
+        "image_caption": [
+            "Figure 3: Critical periods in different DNN architectures and optimization schemes. (Left) Effect of an image blur deficit in a ResNet architecture trained on CIFAR-10 with learning rate annealing and (Center) in a deep fully-connected network trained on MNIST with a fixed learning rate. Different architectures, using different optimization methods and trained on different datasets, still exhibit qualitatively similar critical period behavior. (Right) Same experiment as in Figure 1, but using a fixed learning rate instead of an annealing scheme. Although the time scale of the critical period is longer, the trends are similar, supporting the notion that critical periods cannot be explained solely in terms of the loss landscape of the optimization. (Bottom Left) Networks trained without weight decay have shorter and sharper critical periods. Gradually increasing the weight decay makes the critical period longer, until the point where it stops training properly. (Bottom Right) Using a different optimization method (Adam) we observe a similar behavior to standard SGD. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            102,
+            787,
+            352
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            554,
+            823,
+            583
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Sensory deprivation: We now apply to the network a more drastic deficit, where each image is replaced by white noise. Figure 2 shows hows this extreme deficit exhibits a remarkably less severe effect than the one obtained by only blurring images: Training the network with white noise does not provide any information on the natural images, and results in milder effects than those caused by a deficit (e.g., image blur), which instead conveys some information, but leads the network to (incorrectly) learn that no fine structure is present in the images. A similar effect has been observed in animals, where a period of early sensory deprivation (dark-rearing) can lengthen the critical period and thus cause less severe effects than those documented in light-reared animals (Mower, 1991). We refer the reader to Appendix C for a more detailed comparison between sensory deprivation and training on white noise. ",
+        "bbox": [
+            173,
+            589,
+            825,
+            728
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Architecture, depth, and learning rate annealing: Figure 3 shows that a fully-connected network trained on the MNIST digit classification dataset also shows a critical period for the image blur deficit. Therefore, the convolutional structure is not necessary, nor is the use of natural images. Similarly, a ResNet-18 trained on CIFAR-10 also has a critical period, which is also remarkably sharper than the one found in a standard convolutional network (Figure 1). This is especially interesting, since ResNets allow for easier backpropagation of gradients to the lower layers, thus suggesting that the critical period is not caused by vanishing gradients. However, Figure 2 (Right) shows that the presence of a critical period does indeed depend critically on the depth of the network. In Figure 3, we confirm that a critical period exists even when the network is trained with a constant learning rate, and therefore cannot be explained by an annealed learning rate in later epochs. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Optimization method and weight decay: Figure 3 (Bottom Right) shows that when using Adam as the optimization scheme, which renormalizes the gradients using a running mean of their first two moments, we still observe a critical period similar to that of standard SGD. However, changing the hyperparameters of the optimization can change the shape of the critical period: In Figure 3 (Bottom Left) we show that increasing weight decay makes critical periods longer and less sharp. This can be explained as it both slows the convergence of the network, and it limits the ability of higher layers to change to overcome the deficit, thus encouraging lower layers to also learn new features. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/8fd14e4f6cfa6c6727f089276be690cb67054a32edc04eeafeffa56fca6da7f3.jpg",
+        "image_caption": [
+            "Figure 4: Critical periods in DNNs are traced back to changes in the Fisher Information. (Left) Trace of the Fisher Information of the network weights as a function of the training epoch (blue line), showing two distinct phases of training: First, information sharply increases, but once test performance starts to plateau (green line), the information in the weights decreases during a “consolidation” phase. Eventually less information is stored, yet test accuracy improves slightly (green line). The weights’ Fisher Information correlates strongly with the networks sensitivity to critical periods, computed as in Figure 1 using both a window size of 40 and 60, and fitted here to the Fisher Information using a simple exponential fit. (Center) Recalling the connection between FIM ad connectivity, we may compare it to synaptic density during development in the visual cortex of macaques (Rakic et al., 1986). Here too, a rapid increase in connectivity is followed by elimination of synapses (pruning) continuing throughout life. (Right) Effects of critical period-inducing blurring on the Fisher Information: The impaired network uses more information to solve the task, compared to training in the absence of a deficit, since it is forced to memorize the labels case by case. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            103,
+            821,
+            224
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            446,
+            825,
+            503
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 FISHER INFORMATION ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            526,
+            482,
+            541
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We have established empirically that, in animals and DNNs alike, the initial phases of training are critical to the outcome of the training process. In animals, this strongly relates to changes in the brain architecture of the areas associated with the deficit (Daw, 2014). This is inevitably different in artificial networks, since their connectivity is formally fixed at all times during training. However, not all the connections are equally useful to the network: Consider a network encoding the approximate posterior distribution $p _ { w } ( y | x )$ , parameterized by the weights $w$ , of the task variable $y$ given an input image $x$ . The dependency of the final output from a specific connection can be estimated by perturbing the corresponding weight and looking at the magnitude of the change in the final distribution. Specifically, given a perturbation $w ^ { \\prime } = w + \\delta w$ of the weights, the discrepancy between the $p _ { w } ( y | x )$ and the perturbed network output $p _ { w ^ { \\prime } } ( y | x )$ can be measured by their KullbackLeibler divergence, which, to second-order approximation, is given by: ",
+        "bbox": [
+            173,
+            558,
+            825,
+            710
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c5a80d7db58534ecccb578cabd23b3f16f5c0558608723ec963de5b22faf7e3e.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbb { E } _ { x } \\operatorname { K L } \\big ( p _ { w ^ { \\prime } } ( y | x ) \\| p _ { w } ( y | x ) \\big ) = \\delta w \\cdot F \\delta w + o ( \\delta w ^ { 2 } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            717,
+            673,
+            736
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where the expectation over $x$ is computed using the empirical data distribution $\\hat { Q } ( x )$ given by the dataset, and ",
+        "bbox": [
+            173,
+            746,
+            821,
+            773
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/02c1345b4dc5560223c915bf30ddb6a259bbabac7670c13aa5159d0dc7dec318.jpg",
+        "text": "$$\nF : = \\mathbb { E } _ { x \\sim \\hat { Q } ( x ) } \\mathbb { E } _ { y \\sim p _ { w } ( y | x ) } [ \\nabla _ { w } \\log p _ { w } ( y | x ) \\nabla _ { w } \\log p _ { w } ( y | x ) ^ { T } ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            772,
+            699,
+            794
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "is the Fisher Information Matrix (FIM). The FIM can thus be considered a local metric measuring how much the perturbation of a single weight (or a combination of weights) affects the output of the network (Amari $\\&$ Nagaoka, 2000). In particular, weights with low Fisher Information can be changed or “pruned” with little effect on the network’s performance. This suggests that the Fisher Information can be used as a measure of the effective connectivity of a DNN, or, more generally, of the “synaptic strength” of a connection (Kirkpatrick et al., 2017). Finally, the FIM is also a semidefinite approximation of the Hessian of the loss function (Martens, 2014) and hence of the curvature of the loss landscape at a particular point $w$ during training, providing an elegant connection between the FIM and the optimization procedure (Amari & Nagaoka, 2000), which we will also employ later. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Unfortunately, the full FIM is too large to compute. Rather, we use its trace to measure the global or layer-wise connection strength, which we can compute efficiently using (Appendix A): ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/97c8b882a84f8f35aa5a5f5ce09365204199a7f311336a3e11284ba4a2ccbb70.jpg",
+        "text": "$$\n\\mathrm { t r } ( F ) = \\mathbb { E } _ { \\boldsymbol { x } \\sim \\hat { Q } ( \\boldsymbol { x } ) } \\mathbb { E } _ { \\boldsymbol { y } \\sim p _ { w } ( \\boldsymbol { y } \\vert \\boldsymbol { x } ) } [ \\Vert \\nabla _ { w } \\log p _ { w } ( \\boldsymbol { y } \\vert \\boldsymbol { x } ) \\Vert ^ { 2 } ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            136,
+            665,
+            156
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In order to capture the behavior of the off-diagonal terms, we also tried computing the logdeterminant of the full matrix using the Kronecker-Factorized approximation of Martens & Grosse (2015), but we observed the same qualitative trend as the trace. Since the FIM is a local measure, it is very sensitive to the irregularities of the loss landscape. Therefore, in this section we mainly use ResNets, which have a relatively smooth landscape (Li et al., 2018). For other architectures we use instead a more robust estimator of the FIM based on the injection of noise in the weights (Achille & Soatto, 2018), also described in Appendix A. ",
+        "bbox": [
+            173,
+            160,
+            825,
+            257
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Two phases of learning: As its name suggests, the FIM can be thought as a measure of the quantity of information about the training data that is contained in the model (Fisher, 1925). Based on this, one would expect the overall strength of the connections to increase monotonically as we acquire information from experience. However, this is not the case: While during an initial phase the network acquires information about the data, which results in a large increase in the strength of the connections, once the performance in the task begins to plateau, the network starts decreasing the overall strength of its connections. However, this does not correspond to a reduction in performance, rather, performance keeps slowly improving. This can be seen as a “forgetting, or “compression” phase, during which redundant connections are eliminated and non-relevant variability in the data is discarded. It is well-established how the elimination (“pruning”) of unnecessary synapses is a fundamental process during learning and brain development (Rakic et al., 1986) (Figure 4, Center); in Figure 4 (Left) an analogous phenomenon is clearly and quantitatively shown for DNNs. ",
+        "bbox": [
+            174,
+            263,
+            825,
+            431
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Strikingly, these changes in the connection strength are closely related to the sensitivity to criticalperiod-inducing deficits such as image blur, computed using the “sliding window” method as in Figure 1. In Figure 4 we see that the sensitivity closely follows the trend of the FIM. This is remarkable since the FIM is a local quantity computed at a single point during the training of a network in the absence of deficit, while sensitivity during a critical period is computed, using test data, at the end of the impaired network training. Figure 4 (Right) further emphasizes the effect of deficits on the FIM: in the presence of a deficit, the FIM grows and remains substantially higher even after the deficit is removed. This may be attributed to the fact that, when the data are so corrupted that classification is impossible, the network is forced to memorize the labels, therefore increasing the quantity of information needed to perform the same task. ",
+        "bbox": [
+            173,
+            438,
+            825,
+            577
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Layer-wise effects of deficits: A layer-wise analysis of the FIM sheds further light on how the deficit affects the network. When the network (in this case All-CNN, which has a clearer division among layers than ResNet) is trained without deficits, the most important connections are in the intermediate layers (Figure 5, Left), which can process the input CIFAR-10 image at the most informative intermediate scale. However, if the network is initially trained on blurred data (Figure 5, top right), the strength of the connections is dominated by the top layer (Layer 6). This is to be expected, since the low-level and mid-level structures of the images are destroyed, making the lower layers ineffective. However, if the deficit is removed early in the training (Figure 5, top center), the network manages to “reorganize”, reducing the information contained in the last layer, and, at the same time, increasing the information in the intermediate layers. We refer to these phenomena as changes in “Information Plasticity”. If, however, the data change occurs after the consolidation phase, the network is unable to change its effective connectivity: The connection strength of each layer remains substantially constant. The network has lost its Information Plasticity and is past its critical period. ",
+        "bbox": [
+            173,
+            583,
+            825,
+            777
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Critical periods as bottleneck crossings: The analysis of the FIM also sheds light on the geometry of the loss function and the learning dynamics. Since the FIM can be interpreted as the local curvature of the residual landscape, Fig. 4 shows that learning entails crossing bottlenecks: In the initial phase the network enters regions of high curvature (high Fisher Information), and once consolidation begins, the curvature decreases, allowing it to cross the bottleneck and enter the valley below. If the statistics change after crossing the bottleneck, the network is trapped. In this interpretation, the early phases of convergence are critical in leading the network towards the “right” final valley. The end of critical periods comes after the network has crossed all bottlenecks (and thus learned the features) and entered a wide valley (region of the weight space with low curvature, or low Fisher Information). ",
+        "bbox": [
+            173,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/27672e0cea4143362994d26d892692368ca07dbec1e4ecad3dc5ce7e4237fa85.jpg",
+        "image_caption": [
+            "Figure 5: Normalized quantity of information contained in the weights of each layer as a function of the training epoch. (Top Left) In the absence of deficits, the network relies mostly on the middle layers (3-4-5) to solve the task. (Top Right) In the presence of an image blur deficit until epoch 100, more resources are allocated to the higher layers (6-7) rather than to the middle layers. The blur deficit destroys low- and mid-level features processed by those layers, leaving only the global features of the image, which are processed by the higher layers. Even if the deficit is removed, the middle layers remain underdeveloped. (Top Center) When the deficit is removed at an earlier epoch, the layers can partially reconfigure (notice, e.g., the fast loss of information of layer 6), resulting in less severe long-term consequences. We refer to the redistribution of information and the relative changes in effective connectivity as “Information Plasticity”. (Bottom row) Same plots, but using a vertical flip deficit, which does not induce a critical period. As expected, the quantity of information in the layers is not affected. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            98,
+            802,
+            321
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 DISCUSSION AND RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            530,
+            495,
+            545
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Critical periods have thus far been considered an exclusively biological phenomenon. At the same time, the analysis of DNNs has focused on asymptotic properties and neglected the initial transient behavior. To the best of our knowledge, we are the first to show that artificial neural networks exhibit critical period phenomena, and to highlight the critical role of the transient in determining the asymptotic performance of the network. Inspired by the role of synaptic connectivity in modulating critical periods, we introduce the use of Fisher Information to study this initial phase. We show that the initial sensitivity to deficits closely follows changes in the FIM, both global, as the network first rapidly increases and then decreases the amount of stored information, and layer-wise, as the network “reorganizes” its effective connectivity in order to optimally process information. ",
+        "bbox": [
+            174,
+            561,
+            825,
+            688
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our work naturally relates to the extensive literature on critical periods in biology. Despite artificial networks being an extremely reductionist approximation of neuronal networks, they exhibit behaviors that are qualitatively similar to the critical periods observed in human and animal models. Our information analysis shows that the initial rapid memorization phase is followed by a loss of Information Plasticity which, counterintuitively, further improves the performance. On the other hand, when combined with the analysis of Achille & Soatto (2018) this suggests that a “forgetting” phase may be desirable, or even necessary, in order to learn robust, nuisance-invariant representations. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            791
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The existence of two distinct phases of training has been observed and discussed by Shwartz-Ziv & Tishby (2017), although their analysis builds on the (Shannon) information of the activations, rather than the (Fisher) information in the weights. On a multi-layer perceptron (MLP), Shwartz-Ziv & Tishby (2017) empirically link the two phases to a sudden increase in the gradients’ covariance. It may be tempting to compare these results with our Fisher Information analysis. However, it must be noted that the FIM is computed using the gradients with respect to the model prediction, not to the ground truth label, leading to important qualitative differences. In Figure 6, we show that the covariance and norm of the gradients exhibit no clear trends during training with and without deficits, and, therefore, unlike the FIM, do not correlate with the sensitivity to critical periods. However, a connection between our FIM analysis and the information in the activations can be established based on the work of Achille & Soatto (2018), which shows that the FIM of the weights can be used to bound the information in the activations. In fact, we may intuitively expect that pruning of connections naturally leads to loss of information in the corresponding activations. Thus, our analysis corroborates and expands on some of the claims of Shwartz-Ziv & Tishby (2017), while using an independent framework. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            186
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Aside from being more closely related to the deficit sensitivity during critical periods, Fisher’s Information also has a number of technical advantages: Its diagonal is simple to estimate, even on modern state-of-the-art architectures and compelling datasets, and it is less sensitive to the choice estimator of mutual information, avoiding some of the common criticisms to the use of information quantities in the analysis of deep learning models. Finally, the FIM allows us to probe fine changes in the effective connectivity across the layers of the network (Figure 5), which are not visible in Shwartz-Ziv & Tishby (2017). ",
+        "bbox": [
+            174,
+            194,
+            825,
+            291
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "A complete analysis of the activations should account not only for the amount of information (both task- and nuisance-related), but also for its accessibility, e.g., how easily task-related information can be extracted by a linear classifier. Following a similar idea, Montavon et al. (2011) aim to study the layer-wise, or “spatial” (but not temporal) evolution of the simplicity of the representation by performing a principal component analysis (PCA) of a radial basis function (RBF) kernel embedding of each layer representation. They show that, on a multi-layer perceptron, task-relevant information increasingly concentrate on the first principal components of the representation’s embedding, implying that they become more easily “accessible” layer after layer, while nuisance information (when it is codified at all) is encoded in the remaining components. In our work we instead focus on the temporal evolution of the weights. However, it’s important to notice that a network with simpler weights (as measured by the FIM) also requires a simpler smooth representation (as measured, e.g., by the RBF embedding) in order to operate properly, since it needs to be resistant to perturbations of the weights. Thus our analysis is wholly compatible with the intuitions of Montavon et al. (2011). It would also be interesting to study the joint spatio-temporal evolution of the network using both frameworks at once. ",
+        "bbox": [
+            174,
+            299,
+            825,
+            506
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "One advantage of focusing on the information of the weights rather than on the activations, or behavior of the network, is to have a readout of the “effective connectivity” during critical periods, which can be compared to similar readouts in animals. In fact, “behavioral” readouts upon deficit removal, both in artificial and neuronal networks, can potentially be confounded by deficit-coping changes at different levels of the visual pathways (Daw, 2014; Knudsen, 2004). On the other hand, deficits in deprived animals are mirrored by abnormalities in the circuitry of the visual pathways, which we characterize in DNNs using the FIM to study its “effective connectivity”, i.e., the connections that are actually employed by the network to solve the task. Sensitivity to critical periods and the trace of the Fisher Information peak at the same epochs, in accord with the evidence that skill development and critical periods in neuronal networks are modulated by changes (generally experience-dependent) in synaptic plasticity (Knudsen, 2004; Hensch, 2004). Our layer-wise analysis of the Fisher Information (Figure 5) also shows that visual deficits reinforce higher layers to the detriment of intermediate layers, leaving low-level layers virtually untouched. If the deficit is removed after the critical period ends, the network is not able to reverse these effects. Although the two systems are radically different, a similar response can be found in the visual pathways of animal models: Lower levels (e.g., retina, lateral geniculate nucleus) and higher-level visual areas (e.g., V2 and post-V2) show little remodeling upon deprivation, while most changes happen in different layers of V1 (Wiesel & Hubel, 1963a; Hendrickson et al., 1987). ",
+        "bbox": [
+            174,
+            512,
+            825,
+            763
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "An insightful interpretation of critical periods in animal models was proposed by Knudsen (2004): The initial connections of neuronal networks are unstable and easily modified (highly plastic), but as more “samples” are observed, they change and reach a more stable configuration which is difficult to modify. Learning can, however, still happen within the newly created connectivity pattern. This is largely compatible with our findings: Sensitivity to critical-period-inducing deficits peaks when connections are remodeled (Figure 4, Left), and different connectivity profiles are observed in networks trained with and without a deficit (Figure 5). Moreover, high-level deficits such as imageflipping and label permutation, which do not require restructuring of the network’s connections in order to be corrected, do not exhibit a critical period. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            895
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Applying a deficit at the beginning of the training may be compared to the common practice of pretraining, which is generally found to improve the performance of the network. Erhan et al. (2010) study the somewhat related, but now seldom used, practice of layer-wise unsupervised pre-training, and suggest that it may act as a regularizer by moving the weights of the network towards an area of the loss landscape closer to the attractors for good solutions, and that early examples have a stronger effect in steering the network towards particular solutions. Here, we have shown that pre-training on blurred data can have the opposite effect; i.e., it can severely decrease the final performance of the network. However, in our case, interpreting the deficits effect as moving the network close to a bad attractor is difficult to reconcile with the smooth transition observed in the critical periods, since the network would either converge to this attractor, and thus have low accuracy, or escape completely. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Instead, we reconcile our experiments with the geometry of the loss function by introducing a different explanation based on the interpretation of the FIM as an approximation of the local curvature. Figure 4 suggests that SGD encounters two different phases during the network training: At first, the network moves towards high-curvature regions of the loss landscape, while in the second phase the curvature decreases and the network eventually converges to a flat minimum (as observed in Keskar et al. (2017)). We can interpret these as the network crossing narrow bottlenecks during its training in order to learn useful features, before eventually entering a flat region of the loss surface once learning is completed and ending up trapped there. When combining this assumption with our deficit sensitivity analysis, we can hypothesize that the critical period occurs precisely upon crossing of this bottleneck. It is also worth noticing how there is evidence that convergence to flat minima (minima with low curvature) in a DNN correlates with a good generalization performance (Hochreiter & Schmidhuber, 1997; Li et al., 2018; Chaudhari et al., 2017; Keskar et al., 2017). Indeed, using this interpretation, Figure 4 (Right) tells us that networks more affected by the deficit converge to sharper minima. However, we have also found that the performance of the network is already mostly determined during the early “sensitive��� phase. The final sharpness at convergence may therefore be an epiphenomenon, rather than the cause of good generalization. ",
+        "bbox": [
+            174,
+            250,
+            825,
+            472
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            491,
+            318,
+            507
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Our goal in this paper is not so much to investigate the human (or animal) brain through artificial networks, as to understand fundamental information processing phenomena, both in their biological or artificial implementations. It is also not our goal to suggest that, since they both exhibit critical periods, DNNs are necessarily a valid model of neurobiological information processing, although recent work has emphasized this aspect. We engage in an “Artificial Neuroscience” exercise in part to address a technological need to develop “explainable” artificial intelligence systems whose behavior can be understood and predicted. While traditionally well-understood mathematical models were used by neuroscientists to study biological phenomena, information processing in modern artificial networks is often just as poorly understood as in biology, so we chose to exploit well-known biological phenomena as probes to study information processing in artificial networks. ",
+        "bbox": [
+            174,
+            521,
+            825,
+            660
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Conversely, it would also be interesting to explore ways to test whether biological networks prune connections as a consequences of a loss of Information Plasticity, rather than as a cause. The mechanisms underlying network reconfiguration during learning and development might be an evolutionary outcome obtained under the pressure of fundamental information processing phenomena. ",
+        "bbox": [
+            174,
+            667,
+            823,
+            723
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            738,
+            334,
+            751
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We thank the anonymous reviewers for their thoughtful feedback, and for suggesting new experiments and relevant literature. Supported by ONR N00014-17-1-2072, ARO W911NF-17-1-0304, AFOSR FA9550-15-1-0229 and FA8650-11-1-7156. ",
+        "bbox": [
+            176,
+            762,
+            823,
+            803
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            824,
+            285,
+            839
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alessandro Achille and Stefano Soatto. Emergence of invariance and disentanglement in deep representations. Journal of Machine Learning Research, 19(1):1947–1980, 2018. ",
+        "bbox": [
+            174,
+            847,
+            821,
+            875
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shun-ichi Amari and Hiroshi Nagaoka. Methods of information geometry, volume 191 of Translations of Mathematical Monographs. American Mathematical Society and Oxford University Press, 2000. ",
+        "bbox": [
+            176,
+            881,
+            823,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Martin S Banks, Richard N Aslin, and Robert D Letson. Sensitive period for the development of human binocular vision. Science, 190(4215):675–677, 1975. ",
+        "bbox": [
+            169,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pratik Chaudhari, Anna Choromanska, Stefano Soatto, Yann LeCun, Carlo Baldassi, Christian Borgs, Jennifer Chayes, Levent Sagun, and Riccardo Zecchina. Entropy-sgd: Biasing gradient descent into wide valleys. In Proceedings of the International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            173,
+            140,
+            825,
+            196
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nigel W Daw. Visual Development. Springer, New York, NY, 3rd edition, 2014. ",
+        "bbox": [
+            171,
+            205,
+            697,
+            220
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dumitru Erhan, Yoshua Bengio, Aaron Courville, Pierre-Antoine Manzagol, Pascal Vincent, and Samy Bengio. Why does unsupervised pre-training help deep learning? Journal of Machine Learning Research, 11(Feb):625–660, 2010. ",
+        "bbox": [
+            176,
+            229,
+            823,
+            272
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ronald Aylmer Fisher. Theory of statistical estimation. In Mathematical Proceedings of the Cambridge Philosophical Society, volume 22, pp. 700–725. Cambridge University Press, 1925. ",
+        "bbox": [
+            173,
+            280,
+            823,
+            309
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Fred Giffin and Donald E Mitchell. The rate of recovery of vision after early monocular deprivation in kittens. The Journal of Physiology, 274(1):511–537, 1978. ",
+        "bbox": [
+            171,
+            316,
+            823,
+            347
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            176,
+            354,
+            823,
+            397
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Anita E Hendrickson, JA Movshon, Howard M Eggers, Martin S Gizzi, RG Boothe, and Lynne Kiorpes. Effects of early unilateral blur on the macaque’s visual system. ii. anatomical observations. Journal of Neuroscience, 7(5):1327–1339, 1987. ",
+        "bbox": [
+            174,
+            405,
+            823,
+            449
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Takao K Hensch. Critical period regulation. Annuual review of neuroscience, 27:549–579, 2004. ",
+        "bbox": [
+            171,
+            457,
+            805,
+            473
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Flat minima. ¨ Neural Computation, 9(1):1–42, 1997. ",
+        "bbox": [
+            174,
+            479,
+            799,
+            496
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Eric R Kandel, James H Schwartz, Thomas M Jessell, Steven A Siegelbaum, and A James Hudspeth. Principles of Neural Science. McGraw-Hill, New York, NY, 5th edition, 2013. ",
+        "bbox": [
+            169,
+            503,
+            823,
+            534
+        ],
+        "page_idx": 9
+    },
+    {
+        "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. In Proceedings of the International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            176,
+            541,
+            823,
+            584
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Durk P Kingma, Tim Salimans, and Max Welling. Variational dropout and the local reparameterization trick. In Advances in Neural Information Processing Systems, pp. 2575–2583, 2015. ",
+        "bbox": [
+            171,
+            592,
+            823,
+            622
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al. Overcoming catastrophic forgetting in neural networks. Proceedings of the national academy of sciences, 114(13):3521–3526, 2017. ",
+        "bbox": [
+            173,
+            628,
+            825,
+            686
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Eric I Knudsen. Sensitive periods in the development of the brain and behavior. Journal of cognitive neuroscience, 16(8):1412–1425, 2004. ",
+        "bbox": [
+            173,
+            694,
+            823,
+            723
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ivo Kohler. The formation and transformation of the perceptual world. Psychological Issues Monographs. International Universities Press, Inc., New York, NY, 1964. ",
+        "bbox": [
+            173,
+            732,
+            821,
+            761
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Masakazu Konishi. Birdsong: from behavior to neuron. Annual review of neuroscience, 8(1):125– 170, 1985. ",
+        "bbox": [
+            173,
+            768,
+            821,
+            797
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, University of Toronto, 2009. ",
+        "bbox": [
+            173,
+            806,
+            821,
+            835
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hao Li, Zheng Xu, Gavin Taylor, Christoph Studer, and Tom Goldstein. Visualizing the loss landscape of neural nets. In Advances in Neural Information Processing Systems, pp. 6391–6401, 2018. ",
+        "bbox": [
+            173,
+            843,
+            825,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "James Martens. New insights and perspectives on the natural gradient method. arXiv preprint arXiv:1412.1193, 2014. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "James Martens and Roger Grosse. Optimizing neural networks with kronecker-factored approximate curvature. Proceedings of International Conference on Machine Learning, 37:2408–2417, 2015.   \nDonald E Mitchell. The extent of visual recovery from early monocular or binocular visual deprivation in kittens. The Journal of physiology, 395(1):639–660, 1988.   \nGregoire Montavon, Mikio L Braun, and Klaus-Robert M ´ uller. Kernel analysis of deep networks.¨ Journal of Machine Learning Research, 12(Sep):2563–2581, 2011.   \nGeorge D Mower. The effect of dark rearing on the time course of the critical period in cat visual cortex. Developmental Brain Research, 58(2):151–158, 1991.   \nCarl R Olson and Ralph D Freeman. Profile of the sensitive period for monocular deprivation in kittens. Experimental Brain Research, 39(1):17–21, 1980.   \nPasko Rakic, Jean-Pierre Bourgeois, Maryellen F Eckenhoff, Nada Zecevic, and Patricia S Goldman-Rakic. Concurrent overproduction of synapses in diverse regions of the primate cerebral cortex. Science, 232(4747):232–235, 1986.   \nRavid Shwartz-Ziv and Naftali Tishby. Opening the black box of deep neural networks via information. arXiv preprint arXiv:1703.00810, 2017.   \nJost T Springenberg, Alexey Dosovitskiy, Thomas Brox, and Martin Riedmiller. Striving for simplicity: The all convolutional net. arXiv preprint arXiv:1412.6806, 2014.   \nGeorge M Stratton. Some preliminary experiments on vision without inversion of the retinal image. Psychological Review, 3(6):611–617, 1896.   \nDavid Taylor et al. Critical period for deprivation amblyopia in children. Transactions of the ophthalmological societies of the United Kingdom, 99(3):432–439, 1979.   \nGunter K von Noorden. New clinical aspects of stimulus deprivation amblyopia. American journal of ophthalmology, 92(3):416–421, 1981.   \nTorsten N Wiesel. Postnatal development of the visual cortex and the influence of environment. Nature, 299(5884):583, 1982.   \nTorsten N Wiesel and David H Hubel. Single-cell responses in striate cortex of kittens deprived of vision in one eye. Journal of neurophysiology, 26(6):1003–1017, 1963a.   \nTorsten N Wiesel and David H Hubel. Effects of visual deprivation on morphology and physiology of cells in the cat’s lateral geniculate body. Journal of neurophysiology, 26(6):978–993, 1963b. ",
+        "bbox": [
+            169,
+            92,
+            826,
+            640
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A DETAILS OF THE EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            472,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1 ARCHITECTURES AND TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            135,
+            446,
+            150
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In all of the experiments, unless otherwise stated, we use the following All-CNN architecture, adapted from Springenberg et al. (2014): ",
+        "bbox": [
+            173,
+            161,
+            821,
+            190
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "conv 96 - conv 96 - conv 192 s2 - conv 192 - conv 192 - conv 192 s2 - conv 192 - conv1 192 - conv1 10 - avg. pooling - softmax where each conv block consists of a $3 \\times 3$ convolution, batch normalization and ReLU activations. conv1 denotes a $1 \\times 1$ convolution. The network is trained with SGD, with a batch size of 128, learning rate starting from 0.05 and decaying smoothly by a factor of .97 at each epoch. We also use weight decay with coefficient 0.001. In the experiments with a fixed learning rate, we fix the learning rate to 0.001, which we find to allow convergence without excessive overfitting. For the ResNet experiments, we use the ResNet-18 architecture from He et al. (2016) with initial learning rate 0.1, learning rate decay .97 per epoch, and weight decay 0.0005. When training with Adam, we use a learning rate of 0.001 and weight decay 0.0001. ",
+        "bbox": [
+            179,
+            202,
+            813,
+            232
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            243,
+            826,
+            356
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "When experimenting with varying network depths, we use the following architecture: ",
+        "bbox": [
+            174,
+            362,
+            732,
+            377
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In order to avoid interferences between the annealing scheme and the architecture, in these experiments we fix the learning rate to 0.001. ",
+        "bbox": [
+            173,
+            430,
+            823,
+            459
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The Fully Connected network used for the MNIST experiments has hidden layers of size [2500, 2000, 1500, 1000, 500]. All hidden layers use batch normalization followed by ReLU activations. We fix the learning rate to 0.005. Weight decay is not used. We use data augmentation with random translations up to 4 pixels and random horizontal flipping. For MNIST, we pad the images with zeros to bring them to size $3 2 \\times 3 2$ . ",
+        "bbox": [
+            174,
+            465,
+            825,
+            536
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.2 APPROXIMATIONS OF THE FISHER INFORMATION MATRIX ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            555,
+            620,
+            570
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "To compute the trace of the Fisher Information Matrix, we use the following expression derived directly from the definition: ",
+        "bbox": [
+            173,
+            582,
+            821,
+            611
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/88bb657d6cbecf18c20aa5f17f37af69f20d9bae23dcb6989458f66f6102b8ff.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathrm { t r } ( F ) = \\mathbb { E } _ { x \\sim \\hat { Q } ( x ) } \\mathbb { E } _ { y \\sim p _ { w } ( y \\vert x ) } [ \\mathrm { t r } ( \\nabla _ { w } \\log p _ { w } ( y \\vert x ) \\nabla _ { w } \\log p _ { w } ( y \\vert x ) ^ { T } ) ] } \\\\ & { \\quad \\quad \\quad = \\mathbb { E } _ { x \\sim \\hat { Q } ( x ) } \\mathbb { E } _ { y \\sim p _ { w } ( y \\vert x ) } [ \\Vert \\nabla _ { w } \\log p _ { w } ( y \\vert x ) \\Vert ^ { 2 } ] , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            272,
+            618,
+            723,
+            665
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "where the input image $x$ is sampled from the dataset, while the label $y$ is sampled from the output posterior. Expectations are approximated by Monte-Carlo sampling. Notice, however, that this expression depends only on the local gradients of the loss with respect to the weights at a point $w = w _ { 0 }$ , so it can be noisy when the loss landscape is highly irregular. This is not a problem for ResNets Li et al. (2018), but for other architectures we use instead a different technique, proposed in Achille & Soatto (2018). More in detail, let $L ( w )$ be the standard cross-entropy loss. Given the current weights $w _ { 0 }$ of the network, we find the diagonal matrix $\\Sigma$ that minimizes: ",
+        "bbox": [
+            173,
+            670,
+            825,
+            768
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bb7dd6d4fddadb03f6652c7b18c0dfca80937de4f61761c04e55c0b0cf38d40f.jpg",
+        "text": "$$\nL ^ { \\prime } = \\mathbb { E } _ { w \\sim N ( w _ { 0 } , \\Sigma ) } [ L ( w ) ] - \\beta \\log | \\Sigma | ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            374,
+            776,
+            622,
+            796
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "where $\\beta$ is a parameter that controls the smoothness of the approximation. Notice that $L ^ { \\prime }$ can be minimized efficiently using the method in Kingma et al. (2015). To see how this relates to the Fisher Information Matrix, assume that $L ( w )$ can be approximated locally in $w _ { 0 }$ as $L ( w ) =$ $L _ { 0 } + a \\cdot w + w \\cdot H w$ . We can then rewrite $L ^ { \\prime }$ as ",
+        "bbox": [
+            173,
+            804,
+            825,
+            861
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/afbd57c04a95c598b144107e4583f05a48b09bd0f7e2a2dca13a6b96d396f458.jpg",
+        "text": "$$\n\\begin{array} { r } { L ^ { \\prime } = L _ { 0 } + \\mathrm { t r } ( \\Sigma H ) - \\beta \\log | \\Sigma | . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            869,
+            606,
+            887
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Taking the derivative with respect to $\\Sigma$ , and setting it to zero, we obtain $\\Sigma _ { i i } = \\beta / H _ { i i }$ . We can then use $\\Sigma$ to estimate the trace of the Hessian, and hence of the Fisher information. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.3 CURVE FITTING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            328,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Fitting of sensitivity curves and synaptic density profiles from the literature was performed using: ",
+        "bbox": [
+            169,
+            133,
+            812,
+            150
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c5afbc61e31467d41ef9233dec71af0511260e9133a89e9e4e663bb1025bbfeb.jpg",
+        "text": "$$\nf ( t ) = \\mathrm { e } ^ { - ( t - d ) / \\tau _ { 1 } } - k \\mathrm { e } ^ { - ( t - d ) / \\tau _ { 2 } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            164,
+            607,
+            184
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "as the fitting equation, where $t$ is the age at the time of sampling and $\\tau _ { 1 } , \\tau _ { 2 } , k$ and $d$ are unconstrained parameters (Banks et al., 1975). ",
+        "bbox": [
+            173,
+            199,
+            825,
+            229
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The exponential fit of the sensitivity to the Fisher Information trace uses the expression ",
+        "bbox": [
+            173,
+            234,
+            745,
+            251
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4fd696b9c0170debb4a7da144ad0ccaa9aab3ca3166a314dcfaa8630ce4c8eca.jpg",
+        "text": "$$\nF ( t ) = a \\exp ( c S _ { k } ( t ) ) + b ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            266,
+            588,
+            284
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $a$ , $b$ and $c$ are unconstrained parameters, $F ( t )$ is the Fisher Information trace at epoch $t$ of the training of a network without deficits and $S _ { k }$ is the sensitivity computed using a window of size $k$ . That is, $S _ { k } ( t )$ is the increase in the final test error over a baseline when the network is trained in the presence of a deficit between epochs $t$ and $t + k$ . ",
+        "bbox": [
+            173,
+            299,
+            825,
+            356
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B ADDITIONAL PLOTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            386,
+            375,
+            402
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/fe0370d7f3e28d3a6eda988bd2abb84484acd8448cfad4dfc312bc5796496c83.jpg",
+        "image_caption": [
+            "Figure 6: Log of the norm of the gradient means (solid line) and standard deviation (dashed line) during training when: (Left) No deficit is present, (Center) A blur deficit is present until epoch 70, and (Right) a deficit is present until the last epoch. Notice that the presence of a deficit does not decrease the magnitude of the gradients propagated to the first layers during the last epochs, rather it seems to increase it, suggesting that vanishing gradients are not the cause of the critical period for the blurring deficit. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            439,
+            792,
+            589
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/46f616f0a75dddecb77d81235a32ad0b5eba8f68c46b43b45a7fd7c783e9bb20.jpg",
+        "image_caption": [
+            "Figure 7: Same plot as in Figure 5, but for a noise deficit. Unlike with blur, much more resources are allocated to the lower-layers rather than higher-layers. This may explain why it is easier for the network to reconfigure to solve the task after the deficit is removed. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            724,
+            818,
+            845
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/d0ba0320eb6f0fb9cf03b20dd2ca7b2df008720650c0b49932910d7115a007a3.jpg",
+        "image_caption": [
+            "Figure 8: Visualization of the filters of the first layer of the network used for the experiment in Figure 1. In absence of a deficit, the network learns high-frequency filters, as seen by the fact that many filters are not smooth (first picture). However, when a blurring deficit is present, the network learns only smooth filters corresponding to low-frequencies of the input (third picture). If the deficit is removed after the end of the critical period, the network does not manage to learn high-frequency filters (second picture). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            101,
+            821,
+            223
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "C EXPERIMENTAL DESIGN AND COMPARISON WITH ANIMAL MODELS ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            345,
+            764,
+            361
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Critical periods are task- and deficit-specific. The specific task we address is visual acuity, but the performance is necessarily measured through different mechanisms in animals and Artificial Neural Networks. In animals, visual acuity is traditionally measured by testing the ability to discriminate between black-and-white contrast gratings (with varying spatial frequency) and a uniform gray field. The outcome of such tests generally correlates well with the ability of the animal to use the eye to solve other visual tasks relying on acuity. Convolutional Neural Networks, on the other hand, have a very different sensory processing mechanism (based on heavily quantized data), which may trivialize such a test. Rather, we directly measure the performance of the network on an high-level task, specifically image classification, for which CNNs are optimized. ",
+        "bbox": [
+            174,
+            376,
+            825,
+            502
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We chose to simulate cataracts in our DNN experiments, a deficit which allows us to explore its complex interactions with the structure of the data and the architecture of the network. Unfortunately, while the overall trends of cataract-induced critical periods have been studied and understood in animal models, there is not enough data to confidently regress sensibility curves comparable to those obtained in DNNs. For this reason, in Figure 1 we compare the performance loss in a DNN trained in the presence of a cataract-like deficit with the results obtained from monocularly deprived kittens, which exhibit similar trends and are one of the most common experimental paradigms in the visual neurosciences. ",
+        "bbox": [
+            174,
+            508,
+            825,
+            619
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Simulating complete visual deprivation in a neural network is not as simple as feeding a constant stimulus: a network presented with a constant blank input will rapidly become trivial and thus unable to train on new data. This is to be expected, since a blank input is a perfectly predictable stimulus and thus the network can quickly learn the (trivial) solution to the task. We instead wanted to model an uninformative stimulus, akin to noise. Moreover, even when the eyes are sutured or maintained in the darkness, there will be background excitation of photoreceptors that is best modeled as noise. To account for this, we simulate sensory deprivation by replacing the input images with a dataset composed of (uninformative) random Gaussian noise. This way the network is trained on solving the highly non-trivial task of memorizing the association between the finitely-many noise patterns and their corresponding labels. ",
+        "bbox": [
+            173,
+            627,
+            825,
+            766
+        ],
+        "page_idx": 13
+    }
+]

parse/train/BklEFpEYwS/BklEFpEYwS.md

@@ -0,0 +1,500 @@
+# META-LEARNING WITHOUT MEMORIZATION
+
+Mingzhang $\mathbf { Y i n ^ { 1 2 } }$ , George Tucker2, Mingyuan Zhou1, Sergey Levine23, Chelsea Finn24 mzyin@utexas.edu, gjt@google.com, mingyuan.zhou@mccombs.utexas.edu svlevine@eecs.berkeley.edu, cbfinn@cs.stanford.edu 1UT Austin, 2Google Research, Brain team, 3UC Berkeley, 4Stanford
+
+# ABSTRACT
+
+The ability to learn new concepts with small amounts of data is a critical aspect of intelligence that has proven challenging for deep learning methods. Meta-learning has emerged as a promising technique for leveraging data from previous tasks to enable efficient learning of new tasks. However, most meta-learning algorithms implicitly require that the meta-training tasks be mutually-exclusive, such that no single model can solve all of the tasks at once. For example, when creating tasks for few-shot image classification, prior work uses a per-task random assignment of image classes to N-way classification labels. If this is not done, the meta-learner can ignore the task training data and learn a single model that performs all of the meta-training tasks zero-shot, but does not adapt effectively to new image classes. This requirement means that the user must take great care in designing the tasks, for example by shuffling labels or removing task identifying information from the inputs. In some domains, this makes meta-learning entirely inapplicable. In this paper, we address this challenge by designing a meta-regularization objective using information theory that places precedence on data-driven adaptation. This causes the meta-learner to decide what must be learned from the task training data and what should be inferred from the task testing input. By doing so, our algorithm can successfully use data from non-mutually-exclusive tasks to efficiently adapt to novel tasks. We demonstrate its applicability to both contextual and gradientbased meta-learning algorithms, and apply it in practical settings where applying standard meta-learning has been difficult. Our approach substantially outperforms standard meta-learning algorithms in these settings.
+
+# 1 INTRODUCTION
+
+The ability to learn new concepts and skills with small amounts of data is a critical aspect of intelligence that many machine learning systems lack. Meta-learning (Schmidhuber, 1987) has emerged as a promising approach for enabling systems to quickly learn new tasks by building upon experience from previous related tasks (Thrun & Pratt, 2012; Koch et al., 2015; Santoro et al., 2016; Ravi & Larochelle, 2016; Finn et al., 2017). Meta-learning accomplishes this by explicitly optimizing for few-shot generalization across a set of meta-training tasks. The meta-learner is trained such that, after being presented with a small task training set, it can accurately make predictions on test datapoints for that meta-training task.
+
+While these methods have shown promising results, current methods require careful design of the meta-training tasks to prevent a subtle form of task overfitting, distinct from standard overfitting in supervised learning. If the task can be accurately inferred from the test input alone, then the task training data can be ignored while still achieving low meta-training loss. In effect, the model will collapse to one that makes zero-shot decisions. This presents an opportunity for overfitting where the meta-learner generalizes on meta-training tasks, but fails to adapt when presented with training data from novel tasks. We call this form of overfitting the memorization problem in meta-learning because the meta-learner memorizes a function that solves all of the meta-training tasks, rather than learning to adapt.
+
+Existing meta-learning algorithms implicitly resolve this problem by carefully designing the metatraining tasks such that no single model can solve all tasks zero-shot; we call tasks constructed in this way mutually-exclusive. For example, for $N$ -way classification, each task consists of examples from $N$ randomly sampled classes. The $N$ classes are labeled from 1 to $N$ , and critically, for each task, we randomize the assignment of classes to labels $\{ 1 , 2 , \ldots , N \}$ (visualized in Appendix Figure 3). This ensures that the task-specific class-to-label assignment cannot be inferred from a test input alone. However, the mutually-exclusive tasks requirement places a substantial burden on the user to cleverly design the meta-training setup (e.g., by shuffling labels or omitting goal information). While shuffling labels provides a reasonable mechanism to force tasks to be mutually-exclusive with standard few-shot image classification datasets such as MiniImageNet (Ravi & Larochelle, 2016), this solution cannot be applied to all domains where we would like to utilize meta-learning. For example, consider meta-learning a pose predictor that can adapt to different objects: even if $N$ different objects are used for meta-training, a powerful model can simply learn to ignore the training set for each task, and directly learn to predict the pose of each of the $N$ objects. However, such a model would not be able to adapt to new objects at meta-test time.
+
+The primary contributions of this work are: 1) to identify and formalize the memorization problem in meta-learning, and 2) to propose a meta-regularizer (MR) using information theory as a general approach for mitigating this problem without placing restrictions on the task distribution. We formally differentiate the meta-learning memorization problem from overfitting problem in conventional supervised learning, and empirically show that na¨ıve applications of standard regularization techniques do not solve the memorization problem in meta-learning. The key insight of our metaregularization approach is that the model acquired when memorizing tasks is more complex than the model that results from task-specific adaptation because the memorization model is a single model that simultaneously performs well on all tasks. It needs to contain all information in its weights needed to do well on test points without looking at training points. Therefore we would expect the information content of the weights of a memorization model to be larger, and hence the model should be more complex. As a result, we propose an objective that regularizes the information complexity of the meta-learned function class (motivated by Alemi et al. (2016); Achille & Soatto (2018)). Furthermore, we show that meta-regularization in MAML can be rigorously motivated by a PAC-Bayes bound on generalization. In a series of experiments on non-mutually-exclusive task distributions entailing both few-shot regression and classification, we find that memorization poses a significant challenge for both gradient-based (Finn et al., 2017) and contextual (Garnelo et al., 2018a) meta-learning methods, resulting in near random performance on test tasks in some cases. Our meta-regularization approach enables both of these methods to achieve efficient adaptation and generalization, leading to substantial performance gains across the board on non-mutually-exclusive tasks.
+
+# 2 PRELIMINARIES
+
+We focus on the standard supervised meta-learning problem (see, e.g., Finn et al. (2017)). Briefly, we assume tasks $\mathcal { T } _ { i }$ are sampled from a task distribution $p ( \mathcal { T } )$ . During meta-training, for each task, we observe a set of training data $\mathcal { D } _ { i } = ( \boldsymbol { \mathsf { x } } _ { i } , \boldsymbol { \mathsf { y } } _ { i } )$ and a set of test data $\mathcal { D } _ { i } ^ { * } = ( \boldsymbol { x } _ { i } ^ { * } , \boldsymbol { y } _ { i } ^ { * } )$ with $\pmb { x } _ { i } = ( x _ { i 1 } , \dots , x _ { i K } ) , \pmb { y } _ { i } = ( y _ { i 1 } , \bar { \dots } , y _ { i K } )$ sampled from $p ( x , y | \mathcal { T } _ { i } )$ , and similarly for $\mathcal { D } _ { i } ^ { * }$ . We denote the entire meta-training set as $\mathcal { M } = \{ \mathcal { D } _ { i } , \mathcal { D } _ { i } ^ { * } \} _ { i = 1 } ^ { N }$ . The goal of meta-training is to learn a model for a new task $\tau$ by leveraging what is learned during meta-training and a small amount of training data for the new task $\mathcal { D }$ . We use $\theta$ to denote the meta-parameters learned during meta-training and use $\phi$ to denote the task-specific parameters that are computed based on the task training data.
+
+Following Grant et al. (2018); Gordon et al. (2018), given a meta-training set $\mathcal { M }$ , we consider meta-learning algorithms that maximize conditional likelihood $q ( \hat { y } ^ { * } = y ^ { * } | x ^ { * } , \theta , \mathcal { D } )$ , which is composed of three distributions: $q ( \theta | { \mathcal { M } } )$ that summarizes meta-training data into a distribution on metaparameters, $q ( \phi | \mathcal { D } , \theta )$ that summarizes the per-task training set into a distribution on task-specific parameters, and $q ( \hat { y } ^ { * } | x ^ { * } , \phi , \theta )$ that is the predictive distribution. These distributions are learned to minimize
+
+$$
+\begin{array} { r } { - \frac { 1 } { N } \sum _ { i } \mathbb { E } _ { q ( \theta | \mathcal { M } ) q ( \phi | \mathcal { D } _ { i } , \theta ) } \left[ \frac { 1 } { K } \sum _ { ( x ^ { * } , y ^ { * } ) \in \mathcal { D } _ { i } ^ { * } } \log q ( \hat { y } ^ { * } = y ^ { * } | x ^ { * } , \phi , \theta ) \right] . } \end{array}
+$$
+
+For example, in MAML (Finn et al., 2017), $\theta$ and $\phi$ are the weights of a predictor network, $q ( \theta | { \mathcal { M } } )$ is a delta function learned over the meta-training data, $q ( \phi | \mathcal { D } , \theta )$ is a delta function centered at a point defined by gradient optimization, and $\phi$ parameterizes the predictor network $q ( \hat { y } ^ { * } | x ^ { * } , \phi )$ (Grant et al., 2018). In particular, to determine the task-specific parameters $\phi$ , the task training data $\mathcal { D }$ and $\theta$ are used in the predictor model $\begin{array} { r } { \phi = \theta + \frac { \alpha } { K } \sum _ { ( x , y ) \in { \mathcal { D } } } \nabla _ { \theta } \log q ( y | x , \phi = \theta ) } \end{array}$ .
+
+Another family of meta-learning algorithms are contextual methods (Santoro et al., 2016), such as conditional neural processes (CNP) (Garnelo et al., 2018b;a). CNP instead defines $q ( \phi | \mathcal { D } , \theta )$ as a mapping from $\mathcal { D }$ to a summary statistic $\phi$ (parameterized by $\theta$ ). In particular, $\phi = a _ { \theta } \circ h _ { \theta } ( \mathcal { D } )$ is the output of an aggregator $a _ { \theta } ( \cdot )$ applied to features $h _ { \theta } ( \mathcal { D } )$ extracted from the task training data. Then $\theta$ parameterizes a predictor network that takes $\phi$ and $x ^ { * }$ as input and produces a predictive distribution $\mathbf { \bar { \rho } } _ { q } ( \hat { y } ^ { * } | x ^ { * } , \phi , \theta )$ .
+
+In the following sections, we describe a common pitfall for a variety of meta-learning algorithms, including MAML and CNP, and a general meta-regularization approach to prevent this pitfall.
+
+# 3 THE MEMORIZATION PROBLEM IN META-LEARNING
+
+The ideal meta-learning algorithm will learn in such a way that generalizes to novel tasks. However, we find that unless tasks are carefully designed, current meta-learning algorithms can overfit to the tasks and end up ignoring the task training data (i.e., either $q ( \phi | \mathcal { D } , \theta )$ does not depend on $\mathcal { D }$ or $q ( \hat { y } ^ { * } | x ^ { * } , \phi , \theta )$ does not depend on $\phi$ , as shown in Figure 1), which can lead to poor generalization. This memorization phenomenon is best understood through examples.
+
+Consider a 3D object pose prediction problem (illustrated in Figure 1), where each object has a fixed canonical pose. The $( x , y )$ pairs for the task are 2D grey-scale images of the rotated object $( x )$ and the rotation angle relative to the fixed canonical pose for that object $( y )$ . In the most extreme case, for an unseen object, the task is impossible without using $\mathcal { D }$ because the canonical pose for the unseen object is unknown. The number of objects in the meta-training dataset is small, so it is straightforward for a single network to memorize the canonical pose for each training object and to infer the object from the input image (i.e., task overfitting), thus achieving a low training error without using $\mathcal { D }$ . However, by construction, this solution will necessarily have poor generalization to test tasks with unseen objects.
+
+As another example, imagine an automated medical prescription system that suggests medication prescriptions to doctors based on patient symptoms and the patient’s previous record of prescription responses (i.e., medical history) for adaptation. In the meta-learning framework, each patient represents a separate task. Here, the symptoms and prescriptions have a close relationship, so we cannot assign random prescriptions to symptoms, in contrast to the classification tasks where we can randomly shuffle the labels to create mutually-exclusiveness. For this non-mutually-exclusive task distribution, a standard meta-learning system can memorize the patients’ identity information in the training, leading it to ignore the medical history and only utilize the symptoms combined with the memorized information. As a result, it may issue highly accurate prescriptions on the meta-training set, but fail to adapt to new patients effectively. While such a system would achieve a baseline level of accuracy for new patients, it would be no better than a standard supervised learning method applied to the pooled data.
+
+We formally define (complete) memorization as:
+
+Definition 1 (Complete Meta-Learning Memorization). Complete memorization in meta-learning is when the learned model ignores the task training data such that $I ( \hat { y } ^ { * } ; \mathcal { D } | x ^ { * } , \theta ) ~ = ~ 0$ (i.e., $q ( \hat { y } ^ { * } | x ^ { * } , \theta , \mathcal { D } ) = q ( \hat { y } ^ { * } | x ^ { * } , \theta ) = \mathbb { E } _ { \mathcal { D } ^ { \prime } | x ^ { * } } \left[ q ( \hat { y } ^ { * } | x ^ { * } , \theta , \mathcal { D } ^ { \prime } ) \right] )$ .
+
+Memorization describes an issue with overfitting the meta-training tasks, but it does not preclude the network from generalizing to unseen $( x , y )$ pairs on the tasks similar to the training tasks. Memorization becomes an undesired problem for generalization to new tasks when $I ( y ^ { * } ; \bar { \mathcal { D } | } x ^ { * } ) \gg$ $I ( \hat { y } ^ { * } ; \mathcal { D } | x ^ { * } , \theta )$ (i.e., the task training data is necessary to achieve good performance, even with exact inference under the data generating distribution, to make accurate predictions).
+
+A model with the memorization problem may generalize to new datapoints in training tasks but cannot generalize to novel tasks, which distinguishes it from typical overfitting in supervised learning. In practice, we find that MAML and CNP frequently converge to this memorization solution (Table 2). For MAML, memorization can occur when a particular setting of $\theta$ that does not adapt to the task training data can achieve comparable meta-training error to a solution that adapts $\theta$ . For example, if a setting of $\theta$ can solve all of the meta-training tasks (i.e., for all $( x , y )$ in $\mathcal { D }$ and ${ \mathcal { D } } ^ { * }$ the predictive error is close to zero), the optimization may converge to a stationary point of the MAML objective where minimal adaptation occurs based on the task training set (i.e., $\phi \approx \theta$ ). For a novel task where it is necessary to use the task training data, MAML can in principle still leverage the task training data because the adaptation step is based on gradient descent. However, in practice, the poor initialization of $\theta$ can affect the model’s ability to generalize from a small mount of data. For CNP, memorization can occur when the predictive distribution network $q ( \hat { y } ^ { * } | x ^ { * } , \phi , \theta )$ can achieve low training error without using the task training summary statistics $\phi$ . On a novel task, the network is not trained to use $\phi$ , so it is unable to use the information extracted from the task training set to effectively generalize.
+
+In some problem domains, the memorization problem can be avoided by carefully constructing the tasks. For example, for $N$ -way classification, each task consists of examples from $N$ randomly sampled classes. If the classes are assigned to a random permutation of $N$ for each task, this ensures that the task-specific class-to-label assignment cannot be inferred from the test inputs alone. As a result, a model that ignores the task training data cannot achieve low training error, preventing convergence to the memorization problem. We refer to tasks constructed in this way as mutuallyexclusive. However, the mutually-exclusive tasks requirement places a substantial burden on the user to cleverly design the meta-training setup (e.g., by shuffling labels or omitting goal information) and cannot be applied to all domains where we would like to utilize meta-learning.
+
+![](images/5c5cb71629c85432f9f62f6bd971c50f3c70fb156ef91b77af13f919206ec83d.jpg)  
+Figure 1: Left: An example of non-mutually-exclusive pose prediction tasks, which may lead to the memorization problem. The training tasks are non-mutually-exclusive because the test data label (right) can be inferred accurately without using task training data (left) in the training tasks, by memorizing the canonical orientation of the meta-training objects. For a new object and canonical orientation (bottom), the task cannot be solved without using task training data (bottom left) to infer the canonical orientation. Right: Graphical model for meta-learning. Observed variables are shaded. Without either one of the dashed arrows, ${ \hat { Y } } ^ { * }$ is conditionally independent of $\mathcal { D }$ given $\theta$ and $X ^ { * }$ , which we refer to as complete memorization (Definition 1).
+
+# 4 META REGULARIZATION USING INFORMATION THEORY
+
+At a high level, the sources of information in the predictive distribution $q ( \hat { y } ^ { * } | x ^ { * } , \theta , \mathcal { D } )$ come from the input, the meta-parameters, and the data. The memorization problem occurs when the model encodes task information in the predictive network that is readily available from the task training set (i.e., it memorizes the task information for each meta-training task). We could resolve this problem by encouraging the model to minimize the training error and to rely on the task training dataset as much as possible for the prediction of $y ^ { * }$ (i.e., to maximize $I ( \hat { y } ^ { * } ; \mathcal { D } | x ^ { * } , \theta ) )$ . Explicitly maximizing $I ( \hat { y } ^ { * } ; D | x ^ { * } , \theta )$ requires an intractable marginalization over task training sets to compute $\boldsymbol { q } ( \boldsymbol { \hat { y } } ^ { * } | \boldsymbol { x } ^ { * } , \boldsymbol { \theta } )$ . Instead, we can implicitly encourage it by restricting the information flow from other sources $\boldsymbol { x } ^ { * }$ and $\theta$ ) to $\hat { y } ^ { * }$ . To achieve both low error and low mutual information between $\hat { y } ^ { * }$ and $( x ^ { * } , \theta )$ , the model must use task training data $\mathcal { D }$ to make predictions, hence increasing the mutual information $I ( \hat { y } ^ { * } ; \mathcal { D } | x ^ { * } , \theta )$ , leading to reduced memorization. In this section, we describe two tractable ways to achieve this.
+
+# 4.1 META REGULARIZATION ON ACTIVATIONS
+
+Given $\theta$ , the statistical dependency between $x ^ { * }$ and $\hat { y } ^ { * }$ is controlled by the direct path from $x ^ { * }$ to $\hat { y } ^ { * }$ and the indirect path through $\mathcal { D }$ (see Figure 1), where the latter is desirable because it leverages the task training data. We can control the information flow between $x ^ { * }$ and $\hat { y } ^ { * }$ by introducing an intermediate stochastic bottleneck variable $z ^ { * }$ such that $q ( \hat { y } ^ { * } | x ^ { * } , \phi , \theta ) \ =$ $\begin{array} { r } { \int q ( \hat { y } ^ { * } | z ^ { * } , \phi , \theta ) q ( \zeta ^ { * } | x ^ { * } , \theta ) \ d z ^ { * } } \end{array}$ (Alemi et al., 2016) as shown in Figure 4. Now, we would like to maximize $I ( \hat { y } ^ { * } ; \mathcal { D } | z ^ { * } , \theta )$ to prevent memorization. We can bound this mutual information by
+
+$$
+\begin{array} { r l } & { \quad I ( \hat { y } ^ { * } ; \mathcal { D } | z ^ { * } , \theta ) } \\ & { \geq I ( x ^ { * } ; \hat { y } ^ { * } | \theta , z ^ { * } ) = I ( x ^ { * } ; \hat { y } ^ { * } | \theta ) - I ( x ^ { * } ; z ^ { * } | \theta ) + I ( x ^ { * } ; z ^ { * } | \hat { y } ^ { * } , \theta ) } \\ & { \geq I ( x ^ { * } ; \hat { y } ^ { * } | \theta ) - I ( x ^ { * } ; z ^ { * } | \theta ) } \\ & { = I ( x ^ { * } ; \hat { y } ^ { * } | \theta ) - \mathbb { E } _ { p ( x ^ { * } ) q ( z ^ { * } | x ^ { * } , \theta ) } \left[ \log \frac { q ( z ^ { * } | x ^ { * } , \theta ) } { q ( z ^ { * } | \theta ) } \right] } \\ & { \geq I ( x ^ { * } ; \hat { y } ^ { * } | \theta ) - \mathbb { E } \left[ \log \frac { q ( z ^ { * } | x ^ { * } , \theta ) } { r ( z ^ { * } ) } \right] = I ( x ^ { * } ; \hat { y } ^ { * } | \theta ) - \mathbb { E } \left[ D _ { \mathrm { K L } } ( q ( z ^ { * } | x ^ { * } , \theta ) | | r ( z ^ { * } ) ) \right] } \end{array}
+$$
+
+where $r ( z ^ { * } )$ is a variational approximation to the marginal, the first inequality follows from the statistical dependencies in our model (see Figure 4 and Appendix A.2 for the proof). By simultaneously minimizing $\mathbb { E } \left[ D _ { \mathrm { K L } } \big ( q ( z ^ { * } | x ^ { * } , \theta ) | | r ( z ^ { * } ) \big ) \right]$ and maximizing the mutual information $I ( x ^ { * } ; \hat { y } ^ { * } | \theta )$ , we can implicitly encourage the model to use the task training data $\mathcal { D }$ .
+
+For non-mutually-exclusive problems, the true label $y ^ { * }$ is dependent on $x ^ { * }$ . If the model has the memorization problem and $\bar { I } ( x ^ { * } ; \hat { y } ^ { * } | \theta ) = 0$ , then $q ( \boldsymbol { \hat { y } } ^ { * } | \boldsymbol { x } ^ { * } , \boldsymbol { \hat { \theta } } , \mathcal { D } ) = q ( \boldsymbol { \hat { y } } ^ { * } | \boldsymbol { x } ^ { * } , \boldsymbol { \theta } ) = q ( \boldsymbol { \hat { y } } ^ { * } | \boldsymbol { \theta } )$ , which means the model predictions do not depend on $x ^ { * }$ or $\mathcal { D }$ . Hence, in practical problems, the predictions generated from the model will have low accuracy.
+
+This suggests minimizing the training loss in Eq. (1) can increase $I ( \hat { y } ^ { * } ; \mathcal { D } | x ^ { * } , \theta )$ or $I ( x ^ { * } ; \hat { y } ^ { * } | \theta )$ . Replacing the maximization of $I ( x ^ { * } ; \hat { y } ^ { * } | \theta )$ in Eq. (2) with minimizing the training loss results in the following regularized training objective
+
+$$
+\begin{array} { r } { \frac { 1 } { N } \sum _ { i } \mathbb { E } _ { q ( \theta | M ) q ( \phi | \mathcal { D } _ { i } , \theta ) } \left[ - \frac { 1 } { K } \displaystyle \sum _ { ( x ^ { * } , y ^ { * } ) \in \mathcal { D } _ { i } ^ { * } } \log q ( \hat { y } ^ { * } = y ^ { * } | x ^ { * } , \phi , \theta ) + \beta D _ { \mathrm { K L } } ( q ( z ^ { * } | x ^ { * } , \theta ) | | r ( z ^ { * } ) ) \right] } \end{array}
+$$
+
+where $\log q ( \hat { y } ^ { \ast } | x ^ { \ast } , \phi , \theta )$ is estimated by $\log q ( \hat { y } ^ { \ast } | z ^ { \ast } , \phi , \theta )$ with $z ^ { * } \sim q ( z ^ { * } | x ^ { * } , \theta )$ , $\beta$ modulates the regularizer and $r ( z ^ { * } )$ can be set as $\mathcal { N } ( z ^ { * } ; 0 , I )$ . We refer to this regularizer as meta-regularization (MR) on the activations.
+
+As we demonstrate in Section 6, we find that this regularizer performs well, but in some cases can fail to prevent the memorization problem. Our hypothesis is that in these cases, the network can sidestep the information constraint by storing the prediction of $y ^ { * }$ in a part of $z ^ { * }$ , which incurs a small penalty in Eq. (3) and small lower bound in Eq. (2).
+
+# 4.2 META REGULARIZATION ON WEIGHTS
+
+Alternatively, we can penalize the task information stored in the meta-parameters $\theta$ . Here, we provide an informal argument and provide the complete argument in Appendix A.3. Analogous to the supervised setting (Achille & Soatto, 2018), given meta-training dataset $\mathcal { M }$ , we consider $\theta$ as random variable where the randomness can be introduced by training stochasticity. We model the stochasticity over $\theta$ with a Gaussian distribution $\mathcal { N } ( \boldsymbol { \theta } ; \boldsymbol { \theta } _ { \mu } , \boldsymbol { \theta } _ { \sigma } )$ with learned mean and variance parameters per dimension (Blundell et al., 2015; Achille & Soatto, 2018). By penalizing $I ( y _ { 1 : N } ^ { * } , \mathcal { D } _ { 1 : N } ; \theta | x _ { 1 : N } ^ { * } )$ , we can limit the information about the training tasks stored in the metaparameters $\theta$ and thus require the network to use the task training data to make accurate predictions. We can tractably upper bound it by
+
+$$
+\begin{array} { r } { I ( y _ { 1 : N } ^ { * } , \mathcal { D } _ { 1 : N } ; \theta | x _ { 1 : N } ^ { * } ) = \mathbb { E } \left[ \log \frac { q ( \theta | \mathcal { M } ) } { q ( \theta | x _ { 1 : N } ^ { * } ) } \right] \leq \mathbb { E } \left[ \mathcal { D } _ { \mathrm { K L } } \left( q ( \theta | \mathcal { M } ) \| r ( \theta ) \right) \right] , } \end{array}
+$$
+
+where $r ( \theta )$ is a variational approximation to the marginal, which we set to $\mathcal { N } ( \theta ; 0 , I )$ . In practice, we apply meta-regularization to the meta-parameters $\theta$ that are not used to adapt to the task training data and denote the other parameters as $\tilde { \theta }$ . In this way, we control the complexity of the network that can predict the test labels without using task training data, but we do not limit the complexity of the network that processes the task training data. Our final meta-regularized objective can be written as
+
+$$
+\begin{array} { r } { \frac { 1 } { N } \sum _ { i } \mathbb { E } _ { q ( \theta ; \theta _ { i } , \theta _ { \sigma } ) q ( \delta ) | \mathcal { D } _ { i } , \bar { \theta } ) } \left[ - \frac { 1 } { K } \displaystyle \sum _ { ( x ^ { * } , y ^ { * } ) \in \mathcal { D } _ { \bar { \epsilon } } ^ { * } } \log q ( \hat { y } ^ { * } = y ^ { * } | x ^ { * } , \phi , \theta , \tilde { \theta } ) + \beta D _ { \mathrm { K L } } ( q ( \theta ; \theta _ { \mu } , \theta _ { \sigma } ) | | r ( \theta ) ) \right] } \end{array}
+$$
+
+For MAML, we apply meta-regularization to the parameters uninvolved in the task adaptation. For CNP, we apply meta-regularization to the encoder parameters. The detailed algorithms are shown in Algorithm 1 and 2 in the appendix.
+
+# 4.3 DOES META REGULARIZATION LEAD TO BETTER GENERALIZATION?
+
+Now that we have derived meta regularization approaches for mitigating the memorization problem, we theoretically analyze whether meta regularization leads to better generalization via a PAC-Bayes bound. In particular, we study meta regularization (MR) on the weights (W) of MAML, i.e. MRMAML (W), as a case study.
+
+Meta regularization on the weights of MAML uses a Gaussian distribution $\mathcal { N } ( \boldsymbol { \theta } ; \boldsymbol { \theta } _ { \mu } , \boldsymbol { \theta } _ { \sigma } )$ to model the stochasticity in the weights. Given a task and task training data, the expected error is given by
+
+$$
+e r ( \theta _ { \mu } , \theta _ { \sigma } , \mathcal { D } , \mathcal { T } ) = \mathbb { E } _ { \theta \sim \mathcal { N } ( \theta ; \theta _ { \mu } , \theta _ { \sigma } ) , \phi \sim q ( \phi | \theta , \mathcal { D } ) , ( x ^ { * } , y ^ { * } ) \sim p ( x , y | \mathcal { T } ) } \left[ \mathcal { L } ( x ^ { * } , y ^ { * } , \phi ) \right] ,
+$$
+
+where the prediction loss $\mathcal { L } ( x ^ { * } , y ^ { * } , \phi _ { i } )$ is bounded1. Then, we would like to minimize the error on novel tasks
+
+$$
+e r ( \theta _ { \mu } , \theta _ { \sigma } ) = \mathbb { E } _ { \mathcal { T } \sim p ( \mathcal { T } ) , \mathcal { D } \sim p ( x , y | \mathcal { T } ) } \left[ e r ( \theta _ { \mu } , \theta _ { \sigma } , \mathcal { D } , \mathcal { T } ) \right]
+$$
+
+We only have a finite sample of training tasks, so computing $e r ( Q )$ is intractable, but we can form an empirical estimate:
+
+$$
+\begin{array} { l } { { \displaystyle \quad \displaystyle \hat { e r } ( \theta _ { \mu } , \theta _ { \sigma } , \mathcal { D } _ { 1 } , \mathcal { D } _ { 1 } ^ { * } , . . . , \mathcal { D } _ { n } , \mathcal { D } _ { n } ^ { * } ) } } \\  { \displaystyle = \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \underbrace { \mathbb { E } _ { \theta \sim \mathcal { N } ( \theta ; \theta _ { \mu } , \theta _ { \sigma } ) , \phi _ { i } \sim q ( \phi | \theta , \mathcal { D } _ { i } ) } \left[ - \frac { 1 } { K } \sum _ { ( x ^ { * } , y ^ { * } ) \in \mathcal { D } _ { i } ^ { * } } \log q ( \hat { y } ^ { * } = y ^ { * } | x ^ { * } , \phi _ { i } ) \right] } _ { \displaystyle \hat { e r } ( \theta _ { \mu } , \theta _ { \sigma } , \mathcal { D } _ { i } , \mathcal { D } _ { i } ^ { * } ) } } \end{array}
+$$
+
+where for exposition we have assumed $| \mathcal { D } _ { i } ^ { * } | = K$ are the same for all tasks. We would like to relate $e r ( \theta _ { \mu } , \theta _ { \sigma } )$ and $\hat { e r } ( \theta _ { \mu } , \theta _ { \sigma } , \mathcal { D } _ { 1 } , \mathcal { D } _ { 1 } ^ { * } , . . . , \mathcal { D } _ { n } , \mathcal { D } _ { n } ^ { * } )$ , but the challenge is that $\theta _ { \mu }$ and $\theta _ { \sigma }$ are derived from the meta-training tasks $\mathcal { D } _ { 1 } , \mathcal { D } _ { 1 } ^ { * } , . . . , \mathcal { D } _ { n } , \mathcal { D } _ { n } ^ { * }$ . There are two sources of generalization error: (i) error due to the finite number of observed tasks and (ii) error due to the finite number of examples observed per task. Closely following the arguments in (Amit & Meir, 2018), we apply a standard PAC-Bayes bound to each of these and combine the results with a union bound, resulting in the following Theorem.
+
+Theorem 1. Let $P ( \theta )$ be an arbitrary prior distribution over $\theta$ that does not depend on the metatraining data. Then for any $\delta \in ( 0 , 1 ]$ , with probability at least $1 - \delta$ , the following inequality holds uniformly for all choices of $\theta _ { \mu }$ and $\theta _ { \sigma }$ ,
+
+$$
+\begin{array} { l } { \displaystyle e r ( \theta _ { \mu } , \theta _ { \sigma } ) \leq \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \hat { e } r ( \theta _ { \mu } , \theta _ { \sigma } , \mathcal { D } _ { i } , \mathcal { D } _ { i } ^ { * } ) + } \\ { \displaystyle \left( \sqrt { \frac { 1 } { 2 ( K - 1 ) } } + \sqrt { \frac { 1 } { 2 ( n - 1 ) } } \right) \sqrt { D _ { K L } ( \mathcal { N } ( \theta ; \theta _ { \mu } , \theta _ { \sigma } ) | | P ) + \log \frac { n ( K + 1 ) } { \delta } } , } \end{array}
+$$
+
+where n is the number of meta-training tasks and $K$ is the number of per-task validation datapoints.
+
+We defer the proof to the Appendix A.4. The key difference from the result in (Amit & Meir, 2018) is that we leverage the fact that the task training data is split into training and validation.
+
+In practice, we set $P ( \theta ) = r ( \theta ) = \mathcal { N } ( \theta ; 0 , I )$ . If we can achieve a low value for the bound, then with high probability, our test error will also be low. As shown in the Appendix A.4, by a first order Taylor expansion of the the second term of the RHS in Eq.(9) and setting the coefficient of the KL√ √ term as β = 1/2(K−1)+ 1/2(n−1)√ , we recover the MR-MAML(W) objective (Eq.(5)). $\beta$ tradesoff between the tightness of the generalization bound and the probability that it holds true. The result of this bound suggests that the proposed meta-regularization on weights does indeed improve generalization on the meta-test set.
+
+# 5 RELATED WORK
+
+Previous works have developed approaches for mitigating various forms of overfitting in metalearning. These approaches aim to improve generalization in several ways: by reducing the number of parameters that are adapted in MAML (Zintgraf et al., 2019), by compressing the task embedding (Lee et al., 2019), through data augmentation from a GAN (Zhang et al., 2018), by using an auxiliary objective on task gradients (Guiroy et al., 2019), and via an entropy regularization objective (Jamal & Qi, 2019). These methods all focus on the setting with mutually-exclusive task distributions. We instead recognize and formalize the memorization problem, a particular form of overfitting that manifests itself with non-mutually-exclusive tasks, and offer a general and principled solution. Unlike prior methods, our approach is applicable to both contextual and gradientbased meta-learning methods. We additionally validate that prior regularization approaches, namely TAML (Jamal & Qi, 2019), are not effective for addressing this problem setting.
+
+Our derivation uses a Bayesian interpretation of meta-learning (Tenenbaum, 1999; Fei-Fei et al., 2003; Edwards & Storkey, 2016; Grant et al., 2018; Gordon et al., 2018; Finn et al., 2018; Kim et al., 2018; Harrison et al., 2018). Some Bayesian meta-learning approaches place a distributional loss on the inferred task variables to constrain them to a prior distribution (Garnelo et al., 2018b; Gordon et al., 2018; Rakelly et al., 2019), which amounts to an information bottleneck on the latent task variables. Similarly Zintgraf et al. (2019); Lee et al. (2019); Guiroy et al. (2019) aim to produce simpler or more compressed task adaptation processes. Our approach does the opposite, penalizing information from the inputs and parameters, to encourage the task-specific variables to contain greater information driven by the per-task data.
+
+We use PAC-Bayes theory to study the generalization error of meta-learning and meta-regularization. Pentina & Lampert (2014) extends the single task PAC-Bayes bound (McAllester, 1999) to the multitask setting, which quantifies the gap between empirical error on training tasks and the expected error on new tasks. More recent research shows that, with tightened generalization bounds as the training objective, the algorithms can reduce the test error for mutually-exclusive tasks (Galanti et al., 2016; Amit & Meir, 2018). Our analysis is different from these prior works in that we only include preupdate meta parameters in the generalization bound rather than both pre-update and post-update parameters. In the derivation, we also explicitly consider the splitting of data into the task training set and task validation set, which is aligned with the practical setting.
+
+The memorization problem differs from overfitting in conventional supervised learning in several aspects. First, memorization occurs at the task level rather than datapoint level and the model memorizes functions rather than labels. In particular, within a training task, the model can generalize to new datapoints, but it fails to generalize to new tasks. Second, the source of information for achieving generalization is different. For meta-learning the information is from both the meta-training data and new task training data but in standard supervised setting the information is only from training data. Finally, the aim of regularization is different. In the conventional supervised setting, regularization methods such as weight decay (Krogh & Hertz, 1992), dropout (Srivastava et al., 2014), the information bottleneck (Tishby et al., 2000; Tishby & Zaslavsky, 2015), and Bayes-by-Backprop (Blundell et al., 2015) are used to balance the network complexity and the information in the data. The aim of meta-regularization is different. It governs the model complexity to avoid one complex model solving all tasks, while allowing the model’s dependency on the task data to be complex. We further empirically validate this difference, finding that standard regularization techniques do not solve the memorization problem.
+
+# 6 EXPERIMENTS
+
+In the experimental evaluation, we aim to answer the following questions: (1) How prevalent is the memorization problem across different algorithms and domains? (2) How does the memorization problem affect the performance of algorithms on non-mutually-exclusive task distributions? (3) Is our meta-regularization approach effective for mitigating the problem and is it compatible with multiple types of meta-learning algorithms? (4) Is the problem of memorization empirically distinct from that of the standard overfitting problem?
+
+To answer these questions, we propose several meta-learning problems involving non-mutuallyexclusive task distributions, including two problems that are adapted from prior benchmarks with mutually-exclusive task distributions. We consider model-agnostic meta-learning (MAML) and conditional neural processes (CNP) as representative meta-learning algorithms. We study both variants of our method in combination with MAML and CNP. When comparing with meta-learning algorithms with and without meta-regularization, we use the same neural network architecture, while other hyperparameters are tuned via cross-validation per-problem.
+
+# 6.1 SINUSOID REGRESSION
+
+First, we consider a toy sinusoid regression problem that is non-mutually-exclusive. The data for each task is created in the following way: the amplitude $A$ of the sinusoid is uniformly sampled from a set of 20 equally-spaced points $\{ 0 . 1 , 0 . 3 , \cdot \cdot \cdot , 4 \}$ ; $u$ is sampled uniformly from $[ - 5 , 5 ]$ and $y$ is sampled from $\bar { \mathcal { N } } ( A \bar { \sin ( u ) } , 0 . \bar { 1 } ^ { 2 } )$ . We provide both $u$ and the amplitude $A$ (as a one-hot vector) as input, i.e. $x = ( u , { \dot { A } } )$ . At the test time, we expand the range of the tasks by randomly sampling the data-generating amplitude $A$ uniformly from [0.1, 4] and use a random one-hot vector for the input to the network. The meta-training tasks are a proper subset of the meta-test tasks.
+
+Without the additional amplitude input, both MAML and CNP can easily solve the task and generalize to the meta-test tasks. However, once we add the additional amplitude input which indicates the task identity, we find that both MAML and CNP converge to the complete memorization solution and fail to generalize well to test data (Table 1 and Appendix Figures 7 and 8). Both meta-regularized MAML and CNP (MR-MAML) and (MR-CNP) instead converge to a solution that adapts to the data, and as a result, greatly outperform the unregularized methods.
+
+Table 1: Test MSE for the non-mutually-exclusive sinusoid regression problem. We compare MAML and CNP against meta-regularized MAML (MR-MAML) and meta-regularized CNP (MR-CNP) where regularization is either on the activations (A) or the weights (W). We report the mean over 5 trials and the standard deviation in parentheses.   
+
+<table><tr><td>Methods</td><td>MAML</td><td>MR-MAML (A) MR-MAML (W) (ours)</td><td>(ours)</td><td>CNP</td><td>MR-CNP (A) (ours)</td><td>MR-CNP (W) (ours)</td></tr><tr><td>5 shot</td><td>0.46 (0.04)</td><td>0.17 (0.03)</td><td>0.16 (0.04)</td><td>0.91 (0.10)</td><td>0.10 (0.01)</td><td>0.11 (0.02)</td></tr><tr><td>10 shot</td><td>0.13 (0.01)</td><td>0.07 (0.02)</td><td>0.06 (0.01)</td><td>0.92 (0.05)</td><td>0.09 (0.01)</td><td>0.09 (0.01)</td></tr></table>
+
+# 6.2 POSE PREDICTION
+
+To illustrate the memorization problem on a more realistic task, we create a multi-task regression dataset based on the Pascal 3D data (Xiang et al., 2014) (See Appendix A.5.1 for a complete description). We randomly select 50 objects for meta-training and the other 15 objects for meta-testing. For each object, we use MuJoCo (Todorov et al., 2012) to render images with random orientations of the instance on a table, visualized in Figure 1. For the meta-learning algorithm, the observation $( x )$ is the $1 2 8 \times 1 2 8$ gray-scale image and the label $( y )$ is the orientation relative to a fixed canonical pose. Because the number of objects in the meta-training dataset is small, it is straightforward for a single network to memorize the canonical pose for each training object and to infer the orientation from the input image, thus achieving a low meta-training error without using $\mathcal { D }$ . However, this solution performs poorly at the test time because it has not seen the novel objects and their canonical poses.
+
+Optimization modes and hyperparameter sensitivity. We choose the learning rate from $\{ 0 . 0 0 0 1 $ , $0 . 0 0 0 5 , 0 . 0 0 1 \}$ for each method, $\beta$ from $\{ 1 0 ^ { - 6 } , 1 0 ^ { - 5 } , \cdot \cdot \cdot , 1 \}$ for meta-regularization and report the results with the best hyperparameters (as measured on the meta-validation set) for each method. In this domain, we find that the convergence point of the meta-learning algorithm is determined by both the optimization landscape of the objective and the training dynamics, which vary due to stochastic gradients and the random initialization. In particular, we observe that there are two modes of the objective, one that corresponds to complete memorization and one that corresponds to successful adaptation to the task data. As illustrated in the Appendix, we find that models that converge to a memorization solution have lower training error than solutions which use the task training data, indicating a clear need for meta-regularization. When the meta-regularization is on the activations, the solution that the algorithms converge to depends on the learning rate, while MR on the weights consistently converges to the adaptation solution (See Appendix Figure 9 for the sensitivity analysis). This suggests that MR on the activations is not always successful at preventing memorization. Our hypothesis is that there exists a solution in which the bottlenecked activations encode only the prediction $y ^ { * }$ , and discard other information. Such a solution can achieve both low training MSE and low regularization loss without using task training data, particularly if the predicted label contains a small number of bits (i.e., because the activations will have low information complexity).
+
+However, note that this solution does not achieve low regularization error when applying MR to the weights because the function needed to produce the predicted label does not have low information complexity. As a result, meta-regularization on the weights does not suffer from this pathology and is robust to different learning rates. Therefore, we will use regularization on weights as the proposed methodology in the following experiments and algorithms in Appendix A.1.
+
+Quantitative results. We compare MAML and CNP with their meta-regularized versions (Table 2). We additionally include fine-tuning as baseline, which trains a single network on all the instances jointly, and then fine-tunes on the task training data. Meta-learning with meta-regularization (on weights) outperforms all competing methods by a large margin. We show test error as a function of the meta-regularization coefficient $\beta$ in Appendix Figure 2. The curve reflects the trade-off when changing the amount of information contained in the weights. This indicates that $\beta$ gives a knob that allows us to tune the degree to which the model uses the data to adapt versus relying on the prior.
+
+![](images/5eb44794ca4943d1fcf6fe10b09a7f85a5c4989f737b7ecaa28241d3e651f1dc.jpg)  
+Figure 2: The performance of MAML and CNP with meta-regularization on the weights, as a function of the regularization strength $\beta$ . We observe $\beta$ provides us a knob with which we can control the degree to which the algorithm adapts versus memorizes. When $\beta$ is small, we observe memorization, leading to large test error; when $\beta$ is too large, the network does not store enough information in the weights to perform the task. Crucially, in the middle of these two extremes, meta-regularization is effective in inducing adaptation, leading to good generalization. The plot shows the mean and standard deviation across 5 meta-training runs.
+
+Table 2: Meta-test MSE for the pose prediction problem. We compare MR-MAML (ours) with conventional MAML and fine-tuning (FT). We report the average over 5 trials and standard deviation in parentheses.   
+
+<table><tr><td>Method</td><td>MAML</td><td>MR-MAML (W) (ours)</td><td>CNP</td><td>MR-CNP (W) (ours)</td><td>FT</td><td>FT + Weight Decay</td></tr><tr><td>MSE</td><td>5.39 (1.31)</td><td>2.26 (0.09)</td><td>8.48 (0.12)</td><td>2.89 (0.18)</td><td>7.33 (0.35)</td><td>6.16 (0.12)</td></tr></table>
+
+Comparison to standard regularization. We compare our meta-regularization with standard regularization techniques, weight decay (Krogh & Hertz, 1992) and Bayes-by-Backprop (Blundell et al., 2015), in Table 3. We observe that simply applying standard regularization to all the weights, as in conventional supervised learning, does not solve the memorization problem, which validates that the memorization problem differs from the standard overfitting problem.
+
+Table 3: Meta-testing MSE for the pose prediction problem. We compare MR-CNP (ours) with conventional CNP, CNP with weight decay, and CNP with Bayes-by-Backprop (BbB) regularization on all the weights. We report the average over 5 trials and standard deviation in parentheses.   
+
+<table><tr><td>Methods</td><td>CNP</td><td>CNP + Weight Decay</td><td>CNP + BbB</td><td>MR-CNP (W) (ours)</td></tr><tr><td>MSE</td><td>8.48 (0.12)</td><td>6.86 (0.27)</td><td>7.73 (0.82)</td><td>2.89 (0.18)</td></tr></table>
+
+# 6.3 OMNIGLOT AND MINIIMAGENET CLASSIFICATION
+
+Next, we study memorization in the few-shot classification problem by adapting the few-shot Omniglot (Lake et al., 2011) and MiniImagenet (Ravi & Larochelle, 2016; Vinyals et al., 2016) benchmarks to the non-mutually-exclusive setting. In the non-mutually-exclusive N-way K-shot classification problem, each class is (randomly) assigned a fixed classification label from 1 to N. For each task, we randomly select a corresponding class for each classification label and $K$ task training data points and $K$ task test data points from that class2. This ensures that each class takes only one classification label across tasks and different tasks are non-mutually-exclusive (See Appendix A.5.2 for details).
+
+We evaluate MAML, TAML (Jamal & Qi, 2019), MR-MAML (ours), fine-tuning, and a nearest neighbor baseline on non-mutually-exclusive classification tasks (Table 4). We find that MR-MAML significantly outperforms previous methods on all of these tasks. To better understand the problem, for the MAML variants, we calculate the pre-update accuracy (before adaptation on the task training data) on the meta-training data in Appendix Table 5. The high pre-update meta-training accuracy and low meta-test accuracy are evidence of the memorization problem for MAML and TAML, indicating that it is learning a model that ignores the task data. In contrast, MR-MAML successfully controls the pre-update accuracy to be near chance and encourages the learner to use the task training data to achieve low meta-training error, resulting in good performance at meta-test time.
+
+Finally, we verify that meta-regularization does not degrade performance on the standard mutuallyexclusive task. We evaluate performance as a function of regularization strength on the standard 20-way 1-shot Omniglot task (Appendix Figure 10), and we find that small values of $\beta$ lead to slight improvements over MAML. This indicates that meta-regularization substantially improves performance in the non-mutually-exclusive setting without degrading performance in other settings.
+
+Table 4: Meta-test accuracy on non-mutually-exclusive (NME) classification. The fine-tuning and nearestneighbor baseline results for MiniImagenet are from (Ravi & Larochelle, 2016).   
+
+<table><tr><td>NME Omniglot</td><td>20-way 1-shot</td><td>20-way 5-shot</td></tr><tr><td>MAML</td><td>7.8 (0.2)%</td><td>50.7 (22.9)%</td></tr><tr><td>TAML (Jamal &amp; Qi,2019)</td><td>9.6 (2.3)%</td><td>67.9 (2.3)%</td></tr><tr><td>MR-MAML (W) (ours)</td><td>83.3 (0.8)%</td><td>94.1 (0.1)%</td></tr></table>
+
+<table><tr><td>NME Minilmagenet</td><td></td><td>5-way 1-shot 5-way 5-shot</td></tr><tr><td>Fine-tuning</td><td>28.9 (0.5))%</td><td>49.8 (0.8))%</td></tr><tr><td>Nearest-neighbor</td><td>41.1 (0.7)%</td><td>51.0 (0.7) %</td></tr><tr><td>MAML</td><td>26.3 (0.7)%</td><td>41.6 (2.6)%</td></tr><tr><td>TAML (Jamal &amp; Qi, 2019)</td><td>26.1 (0.6)%</td><td>44.2 (1.7)%</td></tr><tr><td>MR-MAML (W) (ours)</td><td>43.6 (0.6)%</td><td>53.8 (0.9)%</td></tr></table>
+
+# 7 CONCLUSION AND DISCUSSION
+
+Meta-learning has achieved remarkable success in few-shot learning problems. However, we identify a pitfall of current algorithms: the need to create task distributions that are mutually exclusive. This requirement restricts the domains that meta-learning can be applied to. We formalize the failure mode, i.e. the memorization problem, that results from training on non-mutually-exclusive tasks and distinguish it as a function-level overfitting problem compared to the the standard label-level overfitting in supervised learning.
+
+We illustrate the memorization problem with different meta-learning algorithms on a number of domains. To address the problem, we propose an algorithm-agnostic meta-regularization (MR) approach that leverages an information-theoretic perspective of the problem. The key idea is that by placing a soft restriction on the information flow from meta-parameters in prediction of test set labels, we can encourage the meta-learner to use task training data during meta-training. We achieve this by successfully controlling the complexity of model prior to the task adaptation.
+
+The memorization issue is quite broad and is likely to occur in a wide range of real-world applications, for example, personalized speech recognition systems, learning robots that can adapt to different environments (Nagabandi et al., 2018), and learning goal-conditioned manipulation skills using trial-and-error data. Further, this challenge may also be prevalent in other conditional prediction problems, beyond meta-learning, an interesting direction for future study. By both recognizing the challenge of memorization and developing a general and lightweight approach for solving it, we believe that this work represents an important step towards making meta-learning algorithms applicable to and effective on any problem domain.
+
+# ACKNOWLEDGEMENT
+
+The authors would like to thank Alexander A. Alemi, Kevin Murphy, Luke Metz, Abhishek Kumar and the anonymous reviewers for helpful discussions and feedback. M. Yin and M. Zhou acknowledge the support of the U.S. National Science Foundation under Grant IIS-1812699.
+
+# REFERENCES
+
+Alessandro Achille and Stefano Soatto. Emergence of invariance and disentanglement in deep representations. The Journal of Machine Learning Research, 19(1):1947–1980, 2018.
+
+Alexander A Alemi, Ian Fischer, Joshua V Dillon, and Kevin Murphy. Deep variational information bottleneck. arXiv preprint arXiv:1612.00410, 2016.
+
+Ron Amit and Ron Meir. Meta-learning by adjusting priors based on extended pac-bayes theory. In International Conference on Machine Learning, pp. 205–214, 2018.
+
+Charles Blundell, Julien Cornebise, Koray Kavukcuoglu, and Daan Wierstra. Weight uncertainty in neural networks. arXiv preprint arXiv:1505.05424, 2015.
+
+Thomas M Cover and Joy A Thomas. Elements of information theory. John Wiley & Sons, 2012.
+
+Harrison Edwards and Amos Storkey. Towards a neural statistician. arXiv preprint arXiv:1606.02185, 2016.
+
+Li Fei-Fei et al. A bayesian approach to unsupervised one-shot learning of object categories. In Proceedings Ninth IEEE International Conference on Computer Vision, pp. 1134–1141. IEEE, 2003.
+
+Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In Proceedings of the 34th International Conference on Machine LearningVolume 70, pp. 1126–1135. JMLR. org, 2017.
+
+Chelsea Finn, Kelvin Xu, and Sergey Levine. Probabilistic model-agnostic meta-learning. In Advances in Neural Information Processing Systems, pp. 9516–9527, 2018.
+
+Tomer Galanti, Lior Wolf, and Tamir Hazan. A theoretical framework for deep transfer learning. Information and Inference: A Journal of the IMA, 5(2):159–209, 2016.
+
+Marta Garnelo, Dan Rosenbaum, Chris J Maddison, Tiago Ramalho, David Saxton, Murray Shanahan, Yee Whye Teh, Danilo J Rezende, and SM Eslami. Conditional neural processes. arXiv preprint arXiv:1807.01613, 2018a.
+
+Marta Garnelo, Jonathan Schwarz, Dan Rosenbaum, Fabio Viola, Danilo J Rezende, SM Eslami, and Yee Whye Teh. Neural processes. arXiv preprint, 2018b.
+
+Jonathan Gordon, John Bronskill, Matthias Bauer, Sebastian Nowozin, and Richard E Turner. Metalearning probabilistic inference for prediction. arXiv preprint arXiv:1805.09921, 2018.
+
+Erin Grant, Chelsea Finn, Sergey Levine, Trevor Darrell, and Thomas Griffiths. Recasting gradientbased meta-learning as hierarchical bayes. arXiv preprint arXiv:1801.08930, 2018.
+
+Simon Guiroy, Vikas Verma, and Christopher Pal. Towards understanding generalization in gradientbased meta-learning. arXiv preprint arXiv:1907.07287, 2019.
+
+James Harrison, Apoorva Sharma, and Marco Pavone. Meta-learning priors for efficient online bayesian regression. arXiv preprint arXiv:1807.08912, 2018.
+
+Muhammad Abdullah Jamal and Guo-Jun Qi. Task agnostic meta-learning for few-shot learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 11719– 11727, 2019.
+
+Taesup Kim, Jaesik Yoon, Ousmane Dia, Sungwoong Kim, Yoshua Bengio, and Sungjin Ahn. Bayesian model-agnostic meta-learning. arXiv preprint arXiv:1806.03836, 2018.
+
+Gregory Koch, Richard Zemel, and Ruslan Salakhutdinov. Siamese neural networks for one-shot image recognition. In ICML deep learning workshop, volume 2, 2015.
+
+Anders Krogh and John A Hertz. A simple weight decay can improve generalization. In Advances in neural information processing systems, pp. 950–957, 1992.
+
+Brenden Lake, Ruslan Salakhutdinov, Jason Gross, and Joshua Tenenbaum. One shot learning of simple visual concepts. In Proceedings of the annual meeting of the cognitive science society, volume 33, 2011.
+
+Yoonho Lee, Wonjae Kim, and Seungjin Choi. Discrete infomax codes for meta-learning. arXiv preprint arXiv:1905.11656, 2019.
+
+David A McAllester. Pac-bayesian model averaging. In COLT, volume 99, pp. 164–170. Citeseer, 1999.
+
+Anusha Nagabandi, Ignasi Clavera, Simin Liu, Ronald S Fearing, Pieter Abbeel, Sergey Levine, and Chelsea Finn. Learning to adapt in dynamic, real-world environments through metareinforcement learning. arXiv preprint arXiv:1803.11347, 2018.
+
+Anastasia Pentina and Christoph Lampert. A pac-bayesian bound for lifelong learning. In International Conference on Machine Learning, pp. 991–999, 2014.
+
+Kate Rakelly, Aurick Zhou, Deirdre Quillen, Chelsea Finn, and Sergey Levine. Efficient off-policy meta-reinforcement learning via probabilistic context variables. arXiv preprint arXiv:1903.08254, 2019.
+
+Sachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning. In ICLR 2016, 2016.
+
+Adam Santoro, Sergey Bartunov, Matthew Botvinick, Daan Wierstra, and Timothy Lillicrap. Metalearning with memory-augmented neural networks. In International conference on machine learning, pp. 1842–1850, 2016.
+
+Jurgen Schmidhuber. Evolutionary principles in self-referential learning. On learning how to learn: The meta-meta-... hook.) Diploma thesis, Institut f. Informatik, Tech. Univ. Munich, 1:2, 1987.
+
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. The journal of machine learning research, 15(1):1929–1958, 2014.
+
+Joshua Brett Tenenbaum. A Bayesian framework for concept learning. PhD thesis, Massachusetts Institute of Technology, 1999.
+
+Sebastian Thrun and Lorien Pratt. Learning to learn. Springer Science & Business Media, 2012.
+
+Naftali Tishby and Noga Zaslavsky. Deep learning and the information bottleneck principle. In 2015 IEEE Information Theory Workshop (ITW), pp. 1–5. IEEE, 2015.
+
+Naftali Tishby, Fernando C Pereira, and William Bialek. The information bottleneck method. arXiv preprint physics/0004057, 2000.
+
+Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In 2012 IEEE/RSJ International Conference on Intelligent Robots and Systems, pp. 5026–5033. IEEE, 2012.
+
+Oriol Vinyals, Charles Blundell, Timothy Lillicrap, Daan Wierstra, et al. Matching networks for one shot learning. In Advances in neural information processing systems, pp. 3630–3638, 2016.
+
+Yu Xiang, Roozbeh Mottaghi, and Silvio Savarese. Beyond pascal: A benchmark for 3d object detection in the wild. In IEEE Winter Conference on Applications of Computer Vision (WACV), 2014.
+
+Ruixiang Zhang, Tong Che, Zoubin Ghahramani, Yoshua Bengio, and Yangqiu Song. Metagan: An adversarial approach to few-shot learning. In Advances in Neural Information Processing Systems, pp. 2365–2374, 2018.
+
+Luisa M Zintgraf, Kyriacos Shiarlis, Vitaly Kurin, Katja Hofmann, and Shimon Whiteson. Fast context adaptation via meta-learning. In Thirty-sixth International Conference on Machine Learning (ICML 2019), 2019.
+
+# A APPENDIX
+
+# A.1 ALGORITHM
+
+We present the detailed algorithm for meta-regularization on weights with conditional neural processes (CNP) in Algorithm 1 and with model-agnostic meta-learning (MAML) in Algorithm 2. For CNP, we add the regularization on the weights $\theta$ of encoder and leave other weights $\bar { \theta }$ unrestricted. For MAML, we similarly regularize the weights $\theta$ from input to an intermediate hidden layer and leave the weights $\tilde { \theta }$ for adaptation unregularized. In this way, we restrict the complexity of the pre-adaptation model not the post-adaptation model.
+
+# Algorithm 1: Meta-Regularized CNP
+
+input : Task distribution $p ( \mathcal { T } )$ ; Encoder weights distribution $q ( \theta ; \tau ) = \mathcal { N } ( \theta ; \tau )$ with Gaussian parameters $\tau = ( \theta _ { \mu } , \theta _ { \sigma } )$ ; Prior distribution $r ( \theta )$ and Lagrangian multiplier $\beta$ ; $\tilde { \theta }$ that parameterizes feature extractor $h _ { \tilde { \theta } } ( \cdot )$ and decoder $T _ { \tilde { \theta } } ( \cdot )$ . Stepsize $\alpha$ .
+
+output: Network parameter $\tau , { \tilde { \theta } }$
+
+Initialize $\tau$ , $\tilde { \theta }$ randomly; while not converged do
+
+Sample a mini-batch of $\{ \mathcal { T } _ { i } \}$ from $p ( \mathcal { T } )$ ;   
+Sample $\theta \sim q ( \theta ; \tau )$ with reparameterization ;   
+for all $\mathcal { T } _ { i } \in \{ \mathcal { T } _ { i } \}$ do Sample $\mathcal { D } _ { i } = ( \boldsymbol { \boldsymbol { x } } _ { i } , \boldsymbol { \boldsymbol { y } } _ { i } )$ , $\mathcal { D } _ { i } ^ { * } = ( \boldsymbol { x } _ { i } ^ { * } , \boldsymbol { y } _ { i } ^ { * } )$ from $\mathcal { T } _ { i }$ ; Encode observation $z _ { i } = g _ { \theta } ( \pmb { x } _ { i } )$ , $z _ { i } ^ { * } = g _ { \boldsymbol { \theta } } ( \boldsymbol { x } _ { i } ^ { * } )$ ; Compute task context $\phi _ { i } = a ( h _ { \tilde { \theta } } ( z _ { i } , \pmb { y } _ { i } ) )$ with aggregator $a ( \cdot )$ ;
+
+Update $\begin{array} { r } { \tilde { \theta } \gets \tilde { \theta } + \alpha \nabla _ { \tilde { \theta } } \sum _ { \mathcal { T } _ { i } } \log q ( \pmb { y } _ { i } ^ { * } | T _ { \tilde { \theta } } ( \pmb { z } _ { i } ^ { * } , \phi _ { i } ) ) } \end{array}$ ; Update $\begin{array} { r l } & { \sim \sim \sim \smash { \tau } + \alpha \nabla _ { \tau } [ \sum _ { \tau _ { i } } \log q ( { \boldsymbol y } _ { i } ^ { * } | T _ { \tilde { \boldsymbol \theta } } ( { \boldsymbol z } _ { i } ^ { * } , \boldsymbol { \phi } _ { i } ) ) - \beta D _ { \mathrm { K L } } ( q ( { \boldsymbol \theta } ; \tau ) | | \boldsymbol { r } ( { \boldsymbol \theta } ) ) ] } \\ & { \sim \smash { \tau }  \tau + \alpha \nabla _ { \tau } [ \sum _ { \tau _ { i } } \log q ( { \boldsymbol y } _ { i } ^ { * } | T _ { \tilde { \boldsymbol \theta } } ( { \boldsymbol z } _ { i } ^ { * } , { \boldsymbol \phi } _ { i } ) ) - \beta D _ { \mathrm { K L } } ( q ( { \boldsymbol \theta } ; \tau ) | | \boldsymbol { r } ( { \boldsymbol \theta } ) ) ] } \end{array}$
+
+# Algorithm 2: Meta-Regularized MAML
+
+input : Task distribution $p ( \mathcal { T } )$ ; Weights distribution $q ( \theta ; \tau ) = \mathcal { N } ( \theta ; \tau )$ with Gaussian parameters $\tau = ( \theta _ { \mu } , \theta _ { \sigma } )$ ; Prior distribution $r ( \theta )$ and Lagrangian multiplier $\beta$ ; Stepsize $\alpha , \alpha ^ { \prime }$ .
+
+output: Network parameter $\tau , { \tilde { \theta } }$ .
+
+Initialize $\tau$ , $\tilde { \theta }$ randomly; while not converged do
+
+Sample a mini-batch of $\{ \mathcal { T } _ { i } \}$ from $p ( \mathcal { T } )$ ;   
+Sample $\theta \sim q ( \theta ; \tau )$ with reparameterization ;   
+for all $\mathcal { T } _ { i } \in \{ \mathcal { T } _ { i } \}$ do Sample $\mathcal { D } _ { i } = ( \boldsymbol { \boldsymbol { x } } _ { i } , \boldsymbol { \boldsymbol { y } } _ { i } )$ , $\mathcal { D } _ { i } ^ { * } = ( \boldsymbol { x } _ { i } ^ { * } , \boldsymbol { y } _ { i } ^ { * } )$ from $\mathcal { T } _ { i }$ ; Encode observation $z _ { i } = g _ { \theta } ( \pmb { x } _ { i } )$ , $z _ { i } ^ { * } = g _ { \boldsymbol { \theta } } ( \boldsymbol { x } _ { i } ^ { * } )$ ; Compute task specific parameter $\phi _ { i } = \tilde { \theta } + \alpha ^ { \prime } \nabla _ { \tilde { \theta } } \log q ( \pmb { y } _ { i } | \boldsymbol { z } _ { i } , \tilde { \theta } )$ ;
+
+Update $\begin{array} { r } { \tilde { \theta } \gets \tilde { \theta } + \alpha \nabla _ { \tilde { \theta } } \sum _ { \tau _ { i } } \log q ( \pmb { y } _ { i } ^ { * } | \pmb { z } _ { i } ^ { * } , \phi _ { i } ) } \end{array}$ ; Update $\begin{array} { r } { \tau \gets \tau + \alpha \nabla _ { \tau } [ \sum _ { \tau _ { i } } \log q ( \pmb { y } _ { i } ^ { * } | \pmb { z } _ { i } ^ { * } , \phi _ { i } ) - \beta D _ { \mathrm { K L } } ( q ( \theta ; \tau ) | | \boldsymbol { r } ( \theta ) ) ] } \end{array}$
+
+# Algorithm 3: Meta-Regularized Methods in Meta-testing
+
+input : Meta-testing task $\tau$ with training data $\boldsymbol { \mathcal { D } } = ( \boldsymbol { \mathsf { x } } , \boldsymbol { \mathsf { y } } )$ and testing input $\mathbf { \nabla } _ { \mathbf { \mathcal { X } } } ^ { * }$ , optimized parameters $\tau , { \tilde { \theta } }$ .
+
+output: Prediction $\hat { y } ^ { * }$ for $k$ from $I$ to $K$ do
+
+Sample $\theta _ { k } \sim q ( \theta ; \tau )$ ;   
+Encode observation $z _ { k } = g _ { \theta _ { k } } ( \pmb { x } )$ , $z _ { k } ^ { * } = g _ { \theta _ { k } } ( x ^ { * } )$ ;   
+Compute task specific parameter $\phi _ { k } = a ( h _ { \widetilde { \theta } } ( z _ { k } , \pmb { y } ) )$ for MR-CNP and $\phi _ { k } = \tilde { \theta } + \alpha ^ { \prime } \nabla _ { \tilde { \theta } } \log q ( \pmb { y } | \boldsymbol { z } _ { k } , \tilde { \theta } )$ for MR-MAML;   
+Predict $\hat { y } _ { k } ^ { * } \sim q ( \hat { y } ^ { * } | z _ { k } ^ { * } , \phi _ { k } , \tilde { \theta } )$
+
+Return prediction $\begin{array} { r } { \hat { y } ^ { * } = \frac { 1 } { K } \sum _ { k = 1 } ^ { K } \hat { y } _ { k } ^ { * } } \end{array}$
+
+# A.2 META REGULARIZATION ON ACTIVATIONS
+
+We show that $I ( x ^ { * } ; \hat { y } ^ { * } | z ^ { * } , \theta ) \le I ( \hat { y } ^ { * } ; D | z ^ { * } , \theta )$ . By Figure 4, we have that $I ( \hat { y } ^ { \ast } ; x ^ { \ast } | \theta , \mathcal { D } , z ^ { \ast } ) = 0$ By the chain rule of mutual information we have
+
+$$
+\begin{array} { r l } & { I ( \hat { y } ^ { * } ; \mathcal { D } | z ^ { * } , \theta ) = I ( \hat { y } ^ { * } ; \mathcal { D } | z ^ { * } , \theta ) + I ( \hat { y } ^ { * } ; x ^ { * } | \mathcal { D } , \theta , z ^ { * } ) } \\ & { \quad \quad \quad = I ( \hat { y } ^ { * } ; x ^ { * } , \mathcal { D } | \theta , z ^ { * } ) } \\ & { \quad \quad \quad = I ( x ^ { * } ; \hat { y } ^ { * } | \theta , z ^ { * } ) + I ( \hat { y } ^ { * } ; \mathcal { D } | x ^ { * } , \theta , z ^ { * } ) } \\ & { \quad \quad \quad \geq I ( x ^ { * } ; \hat { y } ^ { * } | \theta , z ^ { * } ) } \end{array}
+$$
+
+# A.3 META REGULARIZATION ON WEIGHTS
+
+Similar to (Achille & Soatto, 2018), we use $\xi$ to denote the unknown parameters of the true data generating distribution. This defines a joint distribution $p ( \xi , \mathcal { M } , \theta ) = p ( \xi ) p ( \mathcal { M } | \xi ) q ( \theta | \mathcal { M } )$ . Furthermore, we have a predictive distribution $q ( \hat { y } ^ { * } | x ^ { * } , \mathcal { D } , \theta ) = \mathbb { E } _ { \phi | \theta , \mathcal { D } } \left[ q ( \hat { y } ^ { * } | x ^ { * } , \phi , \theta ) \right]$ .
+
+The meta-training loss in Eq. 1 is an upper bound for the cross entropy $H _ { p , q } ( y _ { 1 : N } ^ { * } | x _ { 1 : N } ^ { * } , \mathcal { D } _ { 1 : N } , \theta )$ . Using an information decomposition of cross entropy (Achille & Soatto, 2018), we have
+
+$$
+\begin{array} { r l } & { H _ { p , q } ( y _ { 1 : N } ^ { * } | x _ { 1 : N } ^ { * } , \mathcal { D } _ { 1 : N } , \theta ) = H ( y _ { 1 : N } ^ { * } | x _ { 1 : N } ^ { * } , \mathcal { D } _ { 1 : N } , \xi ) + I ( \xi ; y _ { 1 : N } ^ { * } | x _ { 1 : N } ^ { * } , \mathcal { D } _ { 1 : N } , \theta ) } \\ & { \qquad + \mathbb { E } \left[ D _ { \mathrm { K L } } ( p ( y _ { 1 : N } ^ { * } | x _ { 1 : N } ^ { * } , \mathcal { D } _ { 1 : N } , \theta ) | | q ( y _ { 1 : N } ^ { * } | x _ { 1 : N } ^ { * } , \mathcal { D } _ { 1 : N } , \theta ) ) \right] + I ( \mathcal { D } _ { 1 : N } ; \theta | x _ { 1 : N } ^ { * } , \xi ) } \\ & { \qquad - I ( y _ { 1 : N } ^ { * } , \mathcal { D } _ { 1 : N } ; \theta | x _ { 1 : N } ^ { * } , \xi ) . } \end{array}
+$$
+
+Here the only negative term is the $I ( y _ { 1 : N } ^ { * } , { \cal D } _ { 1 : N } ; \theta | x _ { 1 : N } ^ { * } , \xi )$ , which quantifies the information that the meta-parameters contain about the meta-training data beyond what can be inferred from the data generating parameters (i.e., memorization). Without proper regularization, the cross entropy loss can be minimized by maximizing this term. We can control its value by upper bounding it
+
+$$
+\begin{array} { r l } & { I ( y _ { 1 : N } ^ { * } , \mathcal { D } _ { 1 : N } ; \theta | x _ { 1 : N } ^ { * } , \xi ) = \mathbb { E } \left[ \log \frac { q ( \theta | \mathcal { M } , \xi ) } { q ( \theta | x _ { 1 : N } ^ { * } , \xi ) } \right] } \\ & { \quad \quad \quad \quad \quad \quad \quad = \mathbb { E } \left[ \log \frac { q ( \theta | \mathcal { M } ) } { q ( \theta | x _ { 1 : N } ^ { * } , \xi ) } \right] } \\ & { \quad \quad \quad \quad = \mathbb { E } \left[ D _ { \mathrm { K L } } ( q ( \theta | \mathcal { M } ) | | q ( \theta | x _ { 1 : N } ^ { * } , \xi ) ) \right] } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \leq \mathbb { E } \left[ D _ { \mathrm { K L } } ( q ( \theta | \mathcal { M } ) | | r ( \theta ) ) \right] , } \end{array}
+$$
+
+where the second equality follows because $\theta$ and $\xi$ are conditionally independent given $\mathcal { M }$ . This gives the regularization in Section 4.2.
+
+# A.4 PROOF OF THE PAC-BAYES GENERALIZATION BOUND
+
+First, we prove a more general result and then specialize it. The goal of the meta-learner is to extract information about the meta-training tasks and the test task training data to serve as a prior for test examples from the novel task. This information will be in terms of a distribution $Q$ over possible models. When learning a new task, the meta-learner uses the training task data $\mathcal { D }$ and a model parameterized by $\theta$ (sampled from $Q ( \theta ) )$ and outputs a distribution $q ( \phi | \mathcal { D } , \theta )$ over models. Our goal is to learn $Q$ such that it performs well on novel tasks.
+
+To formalize this, define
+
+$$
+e r ( Q , \mathcal { D } , \mathcal { T } ) = \mathbb { E } _ { \theta \sim Q ( \theta ) , \phi \sim q ( \phi | \theta , \mathcal { D } ) , ( x ^ { * } , y ^ { * } ) \sim p ( x , y | \mathcal { T } ) } \left[ \mathcal { L } \bigl ( \phi ( x ^ { * } ) , y ^ { * } \bigr ) \right]
+$$
+
+where $\mathcal { L } ( \phi ( x ^ { * } ) , y ^ { * } )$ is a bounded loss in $[ 0 , 1 ]$ . Then, we would like to minimize the error on novel tasks
+
+$$
+e r ( Q ) = \operatorname* { m i n } _ { Q } \mathbb { E } _ { \mathcal { T } \sim p ( \mathcal { T } ) , \mathcal { D } \sim p ( x , y | \mathcal { T } ) } \left[ e r ( Q , \mathcal { D } , \mathcal { T } ) \right]
+$$
+
+Because we only have a finite training set, computing $e r ( Q )$ is intractable, but we can form an empirical estimate:
+
+$$
+\hat { e r } ( Q , \mathcal { D } _ { 1 } , \mathcal { D } _ { 1 } ^ { * } , . . . , \mathcal { D } _ { n } , \mathcal { D } _ { n } ^ { * } ) = \frac { 1 } { n } \underbrace { \sum _ { i = 1 } ^ { n } \mathbb { E } _ { \theta \sim Q ( \theta ) , \phi _ { i } \sim q ( \phi | \theta , \mathcal { D } _ { i } ) } \left[ \frac { 1 } { K } \sum _ { ( x ^ { * } , y ^ { * } ) \in \mathcal { D } _ { i } ^ { * } } \mathcal { L } ( \phi ( x ^ { * } ) , y ^ { * } ) ) \right] } _ { \hat { e r } ( Q , \mathcal { D } _ { i } , \mathcal { D } _ { i } ^ { * } ) }
+$$
+
+where for exposition we assume $K = | \mathcal { D } _ { i } ^ { * } |$ is the same for all $i$ . We would like to relate $e r ( Q )$ and $\hat { e r } ( Q , \mathcal { D } _ { 1 } , \mathcal { D } _ { 1 } ^ { * } , . . . , \mathcal { D } _ { n } , \mathcal { D } _ { n } ^ { * } )$ , but the challenge is that $Q$ may depend on $\mathcal { D } _ { 1 } , \mathcal { D } _ { 1 } ^ { * } , . . . , \mathcal { D } _ { n } , \mathcal { D } _ { n } ^ { * }$ due to the learning algorithm. There are two sources of generalization error: (i) error due to the finite number of observed tasks and (ii) error due to the finite number of examples observed per task. Closely following the arguments in (Amit & Meir, 2018), we apply a standard PAC-Bayes bound to each of these and combine the results with a union bound.
+
+Theorem. Let $Q ( \theta )$ be a distribution over parameters $\theta$ and let $P ( \theta )$ be a prior distribution. Then for any $\delta \in ( 0 , 1 ]$ , with probability at least $1 - \delta _ { \mathrm { { i } } }$ , the following inequality holds uniformly for all distributions $Q$ ,
+
+$$
+\ L _ { T } ( Q ) \leq { \frac { 1 } { n } } \sum _ { i = 1 } ^ { n } { \hat { e } } r ( Q , { \mathcal { D } } _ { i } , { \mathcal { D } } _ { i } ^ { * } ) + \left( { \sqrt { { \frac { 1 } { 2 ( K - 1 ) } } } } + { \sqrt { { \frac { 1 } { 2 ( n - 1 ) } } } } \right) { \sqrt { D _ { K L } ( Q \| P ) + \log { \frac { n ( K + 1 ) } { \delta } } } }
+$$
+
+Proof. To start, we state a classical PAC-Bayes bound and use it to derive generalization bounds on task and datapoint level generalization, respectively.
+
+Theorem 2. Let $\mathcal { X }$ be a sample space (i.e. a space of possible datapoints). Let $P ( X )$ be a distribution over $\mathcal { X }$ (i.e. a data distribution). Let $\Theta$ be a hypothesis space. Given a “loss function” $l ( \theta , X ) : \Theta \times \mathcal { X } \to [ 0 , 1 ]$ and a collection of $M$ i.i.d. random variables sampled from $P ( X )$ , $X _ { 1 } , . . . , X _ { M }$ , let $\pi$ be a prior distribution over hypotheses in $\Theta$ that does not depend on the samples but may depend on the data distribution $P ( X )$ . Then, for any $\delta \in ( 0 , 1 ]$ , the following bound holds uniformly for all posterior distributions $\rho$ over $\Theta$
+
+$$
+P ( \mathbb { E } _ { X _ { i } \sim P ( X ) , \theta \sim \rho ( \cdot ) } [ l ( \theta , X _ { i } ) ] \le \frac { 1 } { M } \sum _ { m = 1 } ^ { M } \mathbb { E } _ { \theta \sim \rho ( \cdot ) } [ l ( \theta , X _ { m } ] + \sqrt { \frac { 1 } { 2 ( M - 1 ) } ( D _ { K L } ( \rho \| \pi ) + \log \frac { M } { \delta } ) } , \forall \rho )  \qquad \mathrm { ( 1 6 ) }
+$$
+
+$e r ( Q )$ leve to $\textstyle { \frac { 1 } { n } } \sum _ { i = 1 } ^ { n } e r ( Q , { D _ { i } } , { T _ { i } } )$ t, we bound the task-leve. Letting the samples be $\begin{array} { r c l } { \bar { X _ { i } } } & { = } & { ( { \mathcal D } _ { i } , { \mathcal T } _ { i } ) } \end{array}$ that , and $l ( \theta , X _ { n } ) ~ =$ $\mathbb { E } _ { \phi _ { i } \sim q ( \phi | \mathcal { D } _ { i } , \theta ) , ( x ^ { * } , y ^ { * } ) \sim \mathcal { T } _ { i } } [ \mathcal { L } ( \phi ( x ^ { * } ) , y ^ { * } ) ]$ , then Theorem 1 says that for any $\delta _ { 0 } \sim ( 0 , 1 ]$
+
+$$
+P \left( e r ( Q ) \leq \frac { 1 } { n } \sum _ { i = 1 } ^ { n } e r ( Q , \mathcal { D } _ { i } , \mathcal { T } _ { i } ) + \sqrt { \frac { 1 } { 2 ( n - 1 ) } \left( D _ { K L } ( Q \| P ) + \log \frac { n } { \delta _ { 0 } } \right) } , \forall Q \right) \geq 1 - \delta _ { 0 } ,
+$$
+
+where $P$ is a prior over $\theta$ .
+
+Within task generalization Next, we relate $e r ( Q , { \mathcal { D } } _ { i } , { \mathcal { T } } _ { i } )$ to $\hat { e r } ( Q , \mathcal { D } _ { i } , \mathcal { D } _ { i } ^ { * } )$ via the PAC-Bayes bound. For a fixed task $i$ , task training data $\mathcal { D } _ { i }$ , a prior $\pi ( \phi | { \mathcal { T } } _ { i } )$ that only depends on the training
+
+data, and any $\delta _ { i } \in ( 0 , 1 ]$ , we have that
+
+$$
+\begin{array} { r l } & { \displaystyle > ( \mathbb { E } _ { ( x ^ { * } , y ^ { * } ) \sim p ( x , y | T _ { i } ) \rho ( \phi _ { i } ) } [ \mathcal { L } ( \phi _ { i } ( x ^ { * } ) , y ^ { * } ) ] \leq \mathbb { E } _ { \rho ( \phi _ { i } ) } [ \frac { 1 } { K } \sum _ { ( x ^ { * } , y ^ { * } ) \in \mathcal { D } _ { i } ^ { * } } \mathcal { L } ( \phi _ { i } ( x ^ { * } ) , y ^ { * } ) ] } \\ & { \quad \quad \quad \quad \quad \quad \quad + \sqrt { \frac { 1 } { 2 ( K - 1 ) } ( D _ { K L } ( { \rho } | | \pi ) + \log \frac { K } { \delta _ { i } } ) } , \forall { \rho } \Big ) \geq 1 - \delta _ { i } . } \end{array}
+$$
+
+Now, we choose $\pi ( \phi | { \mathcal { T } } _ { i } )$ to be $\begin{array} { r l } { \int P ( \theta ) q ( \phi | \theta , \mathcal { D } _ { i } ) d \theta } \end{array}$ and restrict $\rho ( \phi )$ to be of the form $\textstyle { \int Q ( \theta ) q ( \phi | \theta , \mathcal { D } _ { i } ) d \theta }$ for any $Q$ . While, $\pi$ and $\rho$ may be complicated distributions (especially, if they are defined implicitly), we know that with this choice of $\pi$ and $\rho$ $, D _ { K L } ( \rho | | \pi ) \leq D _ { K L } ( Q | | P )$ (Cover & Thomas, 2012), hence, we have
+
+$$
+P \left( e r ( Q , \mathcal { D } _ { i } , \mathcal { T } _ { i } ) \leq \hat { e r } ( Q , \mathcal { D } _ { i } , \mathcal { D } _ { i } ^ { * } ) + \sqrt { \frac { 1 } { 2 ( K - 1 ) } \left( D _ { K L } ( Q \| P ) + \log { \frac { K } { \delta _ { i } } } \right) } , \forall Q \right) \geq 1 - \delta _ { i }
+$$
+
+Overall bound on meta-learner generalization Combining Eq. (17) and (18) using the union bound, we have
+
+$$
+\begin{array} { r l } {  { P \Big ( e r ( Q ) \leq \frac { 1 } { n } \displaystyle \sum _ { i = 1 } ^ { n } \hat { e r } ( Q , \mathcal { D } _ { i } , \mathcal { D } _ { i } ^ { * } ) + \sqrt { \frac { 1 } { 2 ( K - 1 ) } D _ { K L } ( Q \| P ) + \log \frac { K } { \delta _ { i } } } } \quad } & { { } } \\ { + \sqrt { \frac { 1 } { 2 ( n - 1 ) } D _ { K L } ( Q \| P ) + \log \frac { n } { \delta _ { 0 } } } , \forall Q \Big ) \geq 1 - ( \sum _ { i } \delta _ { i } + \delta _ { 0 } ) } & { { } } \end{array}
+$$
+
+Choosing $\begin{array} { r } { \delta _ { 0 } = \frac { \delta } { K + 1 } } \end{array}$ and $\begin{array} { r } { \delta _ { i } = \frac { K \delta } { n ( K + 1 ) } } \end{array}$ , then we have:
+
+$$
+\begin{array} { r l r } {  { P \Big ( e r ( Q ) \leq \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \hat { e } r ( Q , \mathcal { D } _ { i } , \mathcal { D } _ { i } ^ { * } ) + ( \sqrt { \frac { 1 } { 2 ( K - 1 ) } } + \sqrt { \frac { 1 } { 2 ( n - 1 ) } } ) \sqrt { D _ { K L } ( Q \| P ) + \log \frac { n ( K + 1 ) } { \delta } } , \forall Q \Big ) } } \\ & { > 1 - \delta . } &  ( 2 0 \end{array}
+$$
+
+Because $n$ is generally large, by Taylor expansion of the complexity term we have
+
+$$
+\begin{array} { r l } & { \left( \sqrt { \frac { 1 } { 2 ( K - 1 ) } } + \sqrt { \frac { 1 } { 2 ( n - 1 ) } } \right) \sqrt { \left( D _ { K L } Q | | P \rangle + \log \frac { n ( K + 1 ) } { \delta } \right) } } \\ & { = \frac { 1 } { 2 \sqrt { \log n ( K + 1 ) / \delta } } \left( \sqrt { \frac { 1 } { 2 ( K - 1 ) } } + \sqrt { \frac { 1 } { 2 ( n - 1 ) } } \right) \left( D _ { K L } Q | | P \rangle + 2 \log ( \frac { n ( K + 1 ) } { \delta } ) \right) + o ( 1 ) } \end{array}
+$$
+
+Re-defining the coefficient of $\mathrm { K L }$ term as $\beta$ and omitting the constant and higher order term, we recover the meta-regularization bound in Eq.(5) when $Q ( \bar { \theta } ) = \mathcal { N } ( \theta ; \theta _ { \mu } , \theta _ { \sigma } )$ .
+
+# A.5 EXPERIMENTAL DETAILS
+
+# A.5.1 POSE PREDICTION
+
+We create a multi-task regression dataset based on the Pascal 3D data (Xiang et al., 2014). The dataset consists of 10 classes of 3D object such as “aeroplane”, “sofa”, “TV monitor”, etc. Each class has multiple different objects and there are 65 objects in total. We randomly select 50 objects for meta-training and the other 15 objects for meta-testing. For each object, we use MuJoCo (Todorov et al., 2012) to render 100 images with random orientations of the instance on a table, visualized in Figure 1. For the meta-learning algorithm, the observation $( x )$ is the $1 2 8 \times 1 2 8$ gray-scale image and the label $( y )$ is the orientation re-scaled to be within $[ 0 , 1 \dot { 0 } ]$ . For each task, we randomly sample
+
+30 $( x , y )$ pairs for an object and evenly split them between task training and task test data. We use a meta batch-size of 10 tasks per iteration.
+
+For MR-CNP, we use a convolutional encoder with a fully connected bottom layer to map the input image to a 20-dimensional latent representation $z$ and $z ^ { * }$ for task training input $x$ and test input $x ^ { * }$ respectively. The $( z , y )$ are concatenated and mapped by the feature extractor and aggregator which are fully connected networks to the 200 dimensional task summary statistics $\phi$ . The decoder is a fully connected network that maps $( \phi , z ^ { * } )$ to the prediction $\hat { y } ^ { * }$ .
+
+For MR-MAML, we use a convolutional encoder to map the input image to a $1 4 \times 1 4$ dimensional latent representation $z$ and $z ^ { * }$ . The pairs $( z , y )$ are used in the task adaptation step to get a task specific parameter $\phi$ via gradient descent. Then $z ^ { * }$ is mapped to the prediction $\hat { y } ^ { * }$ with a convolutional predictor parameterized by $\phi$ . The network is trained using 5 gradient steps with learning rate 0.01 in the inner loop for adaptation and evaluated using 20 gradient steps at the test-time.
+
+# A.5.2 NON-MUTUALLY-EXCLUSIVE CLASSIFICATION
+
+The Omniglot dataset consists of 20 instances of 1623 characters from 50 different alphabets. We randomly choose 1200 characters for meta-training and use the remaining for testing. The metatraining characters are partitioned into 60 disjoint sets for 20-way classification. The MiniImagenet dataset contains 100 classes of images including 64 training classes, 12 validation classes, and 24 test classes. We randomly partition the 64 meta-training classes into 13 disjoint sets for 5-way classification with one label having one less class of images than the others.
+
+For MR-MAML we use a convolutional encoder similar to the pose prediction problem. The dimension of $z$ and $z ^ { * }$ is $1 4 \times 1 4$ for Omniglot and $2 0 \times 2 0$ for MiniImagenet. We use a convolutional decoder for both datasets. Following (Finn et al., 2017), we use a meta batch-size of 16 for 20-way Omniglot classification and meta batch-size of 4 for 5-way MiniImagenet classification. The metalearning rate is chosen from $\lbrace 0 . 0 0 1 , 0 . 0 0 5 \rbrace$ and the $\beta$ for meta-regularized methods are chosen from $\{ 1 0 ^ { - 7 } , \overset { \vartriangle } { 1 0 ^ { - 6 } } , \dots , 1 0 ^ { - 3 } \}$ . The optimal hyperparameters are chosen for each method separately via cross-validation.
+
+# A.6 ADDITIONAL ILLUSTRATION AND GRAPHICAL MODEL
+
+We show a standard few-shot classification setup in meta-learning to illustrate a mutually-exclusive task distribution and a graphical model for the regularization on the activations.
+
+![](images/5396ede84de50281da40fd81621c726813dfa3e6dd5a08a36ee6f411dd78c147.jpg)  
+Figure 3: An example of mutually-exclusive task distributions. In each task of mutually-exclusive few-shot classification, different classes are randomly assigned to the $N$ -way classification labels. The same class, such as the dog and butterfly in this illustration, can be assigned different labels across tasks which makes it impossible for one model to solve all tasks simultaneously.
+
+![](images/ed215f1ed8d799b43988426f7b9ebc3bc735ebcc0ba6af524e9e98a7a6bbb07f.jpg)  
+Figure 4: Graphical model of the regularization on activations. Observed variables are shaded and $Z$ is bottleneck variable. The complete memorization corresponds to the graph without the dashed arrows.
+
+# A.7 ADDITIONAL RESULTS
+
+As shown in Figures 5, 7 and 8, when meta-learning algorithms converge to the memorization solution, the test tasks must be similar to the train tasks in order to achieve low test error. For CNP, although the task training set contains sufficient information to infer the correct amplitude, this information is ignored and the regression curve at test-time is determined by the one-hot vector. As a result, CNP can only generalize to points from the curves it has seen in the training (Figure 7 first row). On the other hand, MAML does use the task training data (Figure 5, 8 and Table 1), however, its performance is much worse than in the mutually-exclusive task. MR-MAML and MR-CNP avoid converging to a memorization solution and achieve excellent test performance on sinusoid task.
+
+![](images/7690a9fff2a5977010c69799f794ff023adffbdd215ac1f44735fc27de70d704.jpg)  
+Figure 5: Test MSE on the mutually-non-exclusive sinusoid problem as function of the number of gradient steps used in the inner loop of MAML and MR-MAML. For each trial, we calculate the mean MSE over 100 randomly generated meta-testing tasks. We report the mean and standard deviation over 5 random trials.
+
+![](images/69d2480381965d685785cc26b11ab24485ee525f72239401869796f9f4142ae5.jpg)  
+Figure 6: Visualization of the optimized weight matrix $W$ that is connected to the inputs in the sinusoid regression example. The input $x = ( u , A )$ where $u \sim \mathrm { U n i f } ( - 5 , 5 )$ , $A$ is 20 dimensional one-hot vector and the intermediate layer is 100 dimensional, hence $\boldsymbol { x } \in \mathbb { R } ^ { 2 1 }$ and $W \in \mathbb { R } ^ { 2 1 \times 1 0 0 }$ . For both CNP and MAML, the meta-regularization restricts the part of weights that is connected to $A$ close to 0. Therefore it avoids storing the amplitude information in weights and forces the amplitude to be inferred from the task training data $\mathcal { D }$ , hence preventing the memorization problem.
+
+![](images/213a43ad041fd63b7843a387eb38621d3d3593b2fa8255019e61ea29177bfd06.jpg)  
+Figure 7: Meta-test results on the non-mutually-exclusive sinusoid regression problem with CNP. For each row, the amplitudes of the true curves (orange) are randomly sampled uniformly from [0.1, 4]. For illustrative purposes, we fix the one-hot vector component of the input. (a): The vanilla CNP cannot adapt to new task training data at test-time and the shape of prediction curve (blue) is determined by the one-hot amplitude not the task training data. (b) (c): Adding meta-regularization on both activation and weights enables the CNP to use the task training data at meta-training and causes the model to generalize well at test-time.
+
+![](images/8a707bc640c1b0eed86cee56f6acd4628f857b202085673efe68bed1ce20bee7.jpg)  
+Figure 8: Meta-test results on the non-mutually-exclusive sinusoid regression problem with MAML. For each row, the true amplitudes of the true curves (orange) are randomly sampled uniformly from [0.1, 4]. For illustrative purposes, we fix the one-hot vector component of the input. (a): Due to memorization, MAML adapts slowly and has large generalization error at test-time. (b) (c): Adding meta-regularization on both activation and weights recovers efficient adaptation.
+
+![](images/4498cbbefc413ecd8eade6b2ec6b58e9d870304ee03dc6139511a3d7e6bc8f9a.jpg)  
+Figure 9: Sensitivity of activation regularization and weight regularization with respect to the learning rate on the pose prediction problem. For activation regularization, lower training loss corresponds to higher test MSE which indicates that the memorization solution is not solved. For weights regularization, lower training loss corresponds to lower test MSE which indicates proper training can converge to the adaptation solution.
+
+In Table 5, we report the pre-update accuracy for the non-mutually-exclusive classification experiment in Section 6.3. The pre-update accuracy is obtained by the initial parameters $\theta$ rather than the task adapted parameters $\phi$ . At the meta-training time, for both MAML and MR-MAML the post-update accuracy obtained by using $\phi$ gets close to 1. High pre-update accuracy reflects the memorization problem. For example, in 20-way 1-shot Omniglot example, the pre-update accuracy for MAML is ${ \bar { 9 } } 9 . 2 \%$ at the training time, which means only $\bar { 0 . 8 \% }$ improvement in accuracy is due to adaptation, so the task training data is ignored to a large extent. The pre-update training accuracy for MR-MAML is $5 \%$ , which means $9 5 \%$ improvement in accuracy during training is due to the adaptation. This explains why in Table 4, the test accuracy of MR-MAML is much higher than that of MAML at the test-time, since the task training data is used to achieve fast adaptation.
+
+Table 5: Meta-training pre-update accuracy on non-mutually-exclusive classification. MR-MAML controls the meta-training pre-update accuracy close to random guess and achieves low training error after adaptation.   
+
+<table><tr><td>NME Omniglot</td><td>20-way 1-shot</td><td>20-way 5-shot</td></tr><tr><td>MAML</td><td>99.2 (0.2)%</td><td>45.1 (38.9)%</td></tr><tr><td>TAML</td><td>68.9(43.1)%</td><td>6.7 (1.8)%</td></tr><tr><td>MR-MAML (ours)</td><td>5.0 (0)%</td><td>5.0 (0)%</td></tr></table>
+
+Mutually-exclusive Omniglot 20-way 1-shot   
+
+<table><tr><td>NME MiniImagenet5-way 1-shot</td><td></td><td>5-way 5-shot</td></tr><tr><td>MAML</td><td>99.4 (0.1)%</td><td>21.0(1.2)%</td></tr><tr><td>TAML</td><td>99.4 (0.1)%</td><td>20.8(0.4)%</td></tr><tr><td>MR-MAML (ours)</td><td>20.0(0)%</td><td>20.2(0.1)%</td></tr></table>
+
+![](images/1b1b258dacf7a7e02a6a57603a0202a2d519d1888b49e8975a7ee849559cccb2.jpg)  
+Figure 10: The test accuracy of MAML with meta-regularization on the weights as a function of the regularization strength $\beta$ on the mutually-exclusive 20-way 1-shot Omniglot problem. The plot shows the mean and standard deviation across 5 meta-training runs. When $\beta$ is small, MR-MAML slightly outperforms MAML, indicating that meta-regularization does not degrade performance on mutually-exclusive tasks. The accuracy numbers are not directly comparable to previous work (e.g., (Finn et al., 2017)) because we do not use data augmentation.

parse/train/BkxfaTVFwH/BkxfaTVFwH.md

@@ -0,0 +1,348 @@
+# GENESIS: GENERATIVE SCENE INFERENCE AND SAMPLING WITH OBJECT-CENTRIC LATENT REPRESENTATIONS
+
+Martin Engelcke∗∇, Adam R. Kosiorek∇∆, Oiwi Parker Jones∇ & Ingmar Posner∇ ∇ Applied AI Lab, University of Oxford; ∆ Dept. of Statistics, University of Oxford
+
+# ABSTRACT
+
+Generative latent-variable models are emerging as promising tools in robotics and reinforcement learning. Yet, even though tasks in these domains typically involve distinct objects, most state-of-the-art generative models do not explicitly capture the compositional nature of visual scenes. Two recent exceptions, MONet and IODINE, decompose scenes into objects in an unsupervised fashion. Their underlying generative processes, however, do not account for component interactions. Hence, neither of them allows for principled sampling of novel scenes. Here we present GENESIS, the first object-centric generative model of rendered 3D scenes capable of both decomposing and generating scenes by capturing relationships between scene components. GENESIS parameterises a spatial GMM over images which is decoded from a set of object-centric latent variables that are either inferred sequentially in an amortised fashion or sampled from an autoregressive prior. We train GENESIS on several publicly available datasets and evaluate its performance on scene generation, decomposition, and semi-supervised learning.
+
+# 1 INTRODUCTION
+
+Task execution in robotics and reinforcement learning (RL) requires accurate perception of and reasoning about discrete elements in an environment. While supervised methods can be used to identify pertinent objects, it is intractable to collect labels for every scenario and task. Discovering structure in data—such as objects—and learning to represent data in a compact fashion without supervision are long-standing problems in machine learning (Comon, 1992; Tishby et al., 2000), often formulated as generative latent-variable modelling (e.g. Kingma & Welling, 2014; Rezende et al., 2014). Such methods have been leveraged to increase sample efficiency in RL (Gregor et al., 2019) and other supervised tasks (van Steenkiste et al., 2019). They also offer the ability to imagine environments for training (Ha & Schmidhuber, 2018). Given the compositional nature of visual scenes, separating latent representations into object-centric ones can facilitate fast and robust learning (Watters et al., 2019a), while also being amenable to relational reasoning (Santoro et al., 2017). Interestingly, however, state-of-the-art methods for generating realistic images do not account for this discrete structure (Brock et al., 2018; Parmar et al., 2018).
+
+As in the approach proposed in this work, human visual perception is not passive. Rather it involves a creative interplay between external stimulation and an active, internal generative model of the world (Rao & Ballard, 1999; Friston, 2005). That this is necessary can be seen from the physiology of the eye, where the small portion of the visual field that can produce sharp images (fovea centralis) motivates the need for rapid eye movements (saccades) to build up a crisp and holistic percept of a scene (Wandell, 1995). In other words, what we perceive is largely a mental simulation of the external world. Meanwhile, work in computational neuroscience tells us that visual features (see, e.g., Hubel & Wiesel, 1968) can be inferred from the statistics of static images using unsupervised learning (Olshausen & Field, 1996). Experimental investigations further show that specific brain areas (e.g. LO) appear specialised for objects, for example responding more strongly to common objects than to scenes or textures, while responding only weakly to movement (cf. MT) (e.g., GrillSpector & Malach, 2004).
+
+In this work, we are interested in probabilistic generative models that can explain visual scenes compositionally via several latent variables. This corresponds to fitting a probability distribution $p _ { \theta } ( \mathbf { x } )$ with parameters $\theta$ to the data. The compositional structure is captured by $K$ latent variables so that $\begin{array} { r } { p _ { \theta } ( \dot { \mathbf { x } } ) = \int p _ { \theta } ( \mathbf { x } \mid \mathbf { z } _ { 1 : K } ) p _ { \theta } ( \mathbf { z } _ { 1 : K } ) \mathrm { d } \mathbf { z } _ { 1 : K } } \end{array}$ . Models from this family can be optimised using the variational auto-encoder (VAE) framework (Kingma & Welling, 2014; Rezende et al., 2014), by maximising a variational lower bound on the model evidence (Jordan et al., 1999). Burgess et al. (2019) and Greff et al. (2019) recently proposed two such models, MONet and IODINE, to decompose visual scenes into meaningful objects. Both works leverage an analysis-by-synthesis approach through the machinery of VAEs (Kingma & Welling, 2014; Rezende et al., 2014) to train these models without labelled supervision, e.g. in the form of ground truth segmentation masks. However, the models have a factorised prior that treats scene components as independent. Thus, neither provides an object-centric generation mechanism that accounts for relationships between constituent parts of a scene, e.g. two physical objects cannot occupy the same location, prohibiting the component-wise generation of novel scenes and restricting the utility of these approaches. Moreover, MONet embeds a convolutional neural network (CNN) inside of an recurrent neural network (RNN) that is unrolled for each scene component, which does not scale well to more complex scenes. Similarly, IODINE utilises a CNN within an expensive, gradient-based iterative refinement mechanism.
+
+Therefore, we introduce GENErative Scene Inference and Sampling (GENESIS) which is, to the best of our knowledge, the first object-centric generative model of rendered 3D scenes capable of both decomposing and generating scenes1. Compared to previous work, this renders GENESIS significantly more suitable for a wide range of applications in robotics and reinforcement learning. GENESIS achieves this by modelling relationships between scene components with an expressive, autoregressive prior that is learned alongside a sequential, amortised inference network. Importantly, sequential inference is performed in low-dimensional latent space, allowing all convolutional encoders and decoders to be run in parallel to fully exploit modern graphics processing hardware.
+
+We conduct experiments on three canonical and publicly available datasets: coloured Multi-dSprites (Burgess et al., 2019), the GQN dataset (Eslami et al., 2018), and ShapeStacks (Groth et al., 2018). The latter two are simulated 3D environments which serve as testing grounds for navigation and object manipulation tasks, respectively. We show both qualitatively and quantitatively that in contrast to prior art, GENESIS is able to generate coherent scenes while also performing well on scene decomposition. Furthermore, we use the scene annotations available for ShapeStacks to show the benefit of utilising general purpose, object-centric latent representations from GENESIS for tasks such as predicting whether a block tower is stable or not.
+
+Code and models are available at https://github.com/applied-ai-lab/genesis.
+
+# 2 RELATED WORK
+
+Structured Models Several methods leverage structured latent variables to discover objects in images without direct supervision. CST-VAE (Huang & Murphy, 2015), AIR (Eslami et al., 2016), SQAIR (Kosiorek et al., 2018), and SPAIR (Crawford & Pineau, 2019) use spatial attention to partition scenes into objects. TAGGER (Greff et al., 2016), NEM (Greff et al., 2017), and R-NEM (van Steenkiste et al., 2018a) perform unsupervised segmentation by modelling images as spatial mixture models. SCAE (Kosiorek et al., 2019) discovers geometric relationships between objects and their parts by using an affine-aware decoder. Yet, these approaches have not been shown to work on more complex images, for example visual scenes with 3D spatial structure, occlusion, perspective distortion, and multiple foreground and background components as considered in this work. Moreover, none of them demonstrate the ability to generate novel scenes with relational structure.
+
+While Xu et al. (2018) present an extension of Eslami et al. (2016) to generate images, their method only works on binary images with a uniform black background and assumes that object bounding boxes do not overlap. In contrast, we train GENESIS on rendered 3D scenes from Eslami et al. (2018) and Groth et al. (2018) which feature complex backgrounds and considerable occlusion to perform both decomposition and generation. Lastly, Xu et al. (2019) use ground truth pixel-wise flow fields as a cue for segmenting objects or object parts. Similarly, GENESIS could be adapted to also leverage temporal information which is a promising avenue for future research.
+
+MONet & IODINE While this work is most directly related to MONet (Burgess et al., 2019) and IODINE (Greff et al., 2019), it sets itself apart by introducing a generative model that captures relations between scene components with an autoregressive prior, enabling the unconditional generation of coherent, novel scenes. Moreover, MONet relies on a deterministic attention mechanism rather than utilising a proper probabilistic inference procedure. This implies that the training objective is not a valid lower bound on the marginal likelihood and that the model cannot perform density estimation without modification. Furthermore, this attention mechanism embeds a CNN in a RNN, posing an issue in terms of scalability. These two considerations do not apply to IODINE, but IODINE employs a gradient-based, iterative refinement mechanism which expensive both in terms of computation and memory, limiting its practicality and utility. Architecturally, GENESIS is more similar to MONet and does not require expensive iterative refinement as IODINE. Unlike MONet, though, the convolutional encoders and decoders in GENESIS can be run in parallel, rendering the model computationally more scalable to inputs with a larger number of scene components.
+
+Adversarial Methods A few recent works have proposed to use an adversary for scene segmentation and generation. Chen et al. (2019) and Bielski & Favaro (2019) segment a single foreground object per image and Arandjelovic & Zisserman (2019) segment several synthetic objects superim- ´ posed on natural images. Azadi et al. (2019) combine two objects or an object and a background scene in a sensible fashion and van Steenkiste et al. (2018b) can generate scenes with a potentially arbitrary number of components. In comparison, GENESIS performs both inference and generation, does not exhibit the instabilities of adversarial training, and offers a probabilistic formulation which captures uncertainty, e.g. during scene decomposition. Furthermore, the complexity of GENESIS increases with $\mathcal O ( K )$ , where $K$ is the number of components, as opposed to the $\mathcal { O } ( K ^ { 2 } )$ complexity of the relational stage in van Steenkiste et al. (2018b).
+
+Inverse Graphics A range of works formulate scene understanding as an inverse graphics problem. These well-engineered methods, however, rely on scene annotations for training and lack probabilistic formulations. For example, Wu et al. (2017b) leverage a graphics renderer to decode a structured scene description which is inferred by a neural network. Romaszko et al. (2017) pursue a similar approach but instead make use of a differentiable graphics render. Wu et al. (2017a) further employ different physics engines to predict the movement of billiard balls and block towers.
+
+# 3 GENESIS: GENERATIVE SCENE INFERENCE AND SAMPLING
+
+In this section, we first describe the generative model of GENESIS and a simplified variant called GENESIS-S. This is followed by the associated inference procedures and two possible learning objectives. GENESIS is illustrated in Figure 1 and Figure 2 shows the graphical model in comparison to alternative methods. An illustration of GENESIS-S is included Appendix B.1, Figure 5.
+
+Generative model Let $\mathbf { x } \in \mathbb { R } ^ { H \times W \times C }$ be an image. We formulate the problem of image generation as a spatial Gaussian mixture model (GMM). That is, every Gaussian component $k = 1 , \ldots , K$ represents an image-sized scene component $\mathbf { x } _ { k } \in \mathbb { R } ^ { H \times W \times C }$ . $K \in \mathbb { N } _ { + }$ is the maximum number of scene components. The corresponding mixing probabilities $\pi _ { k } \in [ \dot { 0 } , 1 ] ^ { H \times W }$ indicate whether the component is present at a location in the image. The mixing probabilities are normalised across scene components, i.e. $\begin{array} { r } { \forall _ { i , j } \sum _ { k } \pi _ { i , j , k } = 1 } \end{array}$ , and can be regarded as spatial attention masks. Since there are strong spatial dependencies between components, we formulate an autoregressive prior distribution over mask variables $\mathbf { z } _ { k } ^ { m } \in \mathbb { R } ^ { D _ { m } }$ which encode the mixing probabilities $\pi _ { k }$ , as
+
+$$
+p _ { \theta } ( \mathbf { z } _ { 1 : K } ^ { m } ) = \prod _ { k = 1 } ^ { K } p _ { \theta } \big ( \mathbf { z } _ { k } ^ { m } \mid \mathbf { z } _ { 1 : k - 1 } ^ { m } \big ) = \prod _ { k = 1 } ^ { K } p _ { \theta } ( \mathbf { z } _ { k } ^ { m } \mid \mathbf { u } _ { k } ) \vert _ { \mathbf { u } _ { k } = \mathrm { R } _ { \theta } ( \mathbf { z } _ { k - 1 } ^ { m } , \mathbf { u } _ { k - 1 } ) } .
+$$
+
+The dependence on previous latents $\mathbf { z } _ { 1 : k - 1 } ^ { m }$ is implemented via an RNN $\mathrm { R } _ { \theta }$ with hidden state $\mathbf { u } _ { k }$
+
+Next, we assume that the scene components $\mathbf { x } _ { k }$ are conditionally independent given their spatial allocation in the scene. The corresponding conditional distribution over component variables $\mathbf { z } _ { k } ^ { c } \in \mathbb { R } ^ { D _ { c } }$ which encode the scene components $\mathbf { x } _ { k }$ factorises as follows,
+
+$$
+p _ { \boldsymbol { \theta } } ( \mathbf { z } _ { 1 : K } ^ { c } \mid \mathbf { z } _ { 1 : K } ^ { m } ) = \prod _ { k = 1 } ^ { K } p _ { \boldsymbol { \theta } } ( \mathbf { z } _ { k } ^ { c } \mid \mathbf { z } _ { k } ^ { m } ) .
+$$
+
+![](images/7b549da9427012cef5abadef61029f537b67a57f5aec466fc26eef046d7742f4.jpg)  
+Figure 1: GENESIS illustration. Given an image $\mathbf { x }$ , an encoder and an RNN compute the mask latents $\mathbf { z } _ { k } ^ { m }$ . These are decoded to obtain the mixing probabilities $\pi _ { k }$ . The image and individual masks are concatenated to infer the component latents $\mathbf { z } _ { k } ^ { c }$ from which the scene components $\mathbf { x } _ { k }$ are decoded.
+
+Now, the image likelihood is given by a mixture model,
+
+$$
+p ( \mathbf { x } \mid \mathbf { z } _ { 1 : K } ^ { m } , \mathbf { z } _ { 1 : K } ^ { c } ) = \sum _ { k = 1 } ^ { K } \pi _ { k } p _ { \theta } ( \mathbf { x } _ { k } \mid \mathbf { z } _ { k } ^ { c } ) ,
+$$
+
+where the mixing probabilities $\pi _ { k } = \pi _ { \theta } ( \mathbf { z } _ { 1 : k } ^ { m } )$ are created via a stick-breaking process (SBP) adapted from Burgess et al. (2019) as follows, slightly overloading the $\pi$ notation,
+
+$$
+\pi _ { 1 } = \pi _ { \theta } ( { \bf z } _ { 1 } ^ { m } ) , \qquad \pi _ { k } = \left( 1 - \sum _ { j = 1 } ^ { k - 1 } \pi _ { j } \right) \pi _ { \theta } ( { \bf z } _ { k } ^ { m } ) , \qquad \pi _ { K } = \left( 1 - \sum _ { j = 1 } ^ { K - 1 } \pi _ { j } \right) .
+$$
+
+Note that this step is not necessary for our model and instead one could use a softmax to normalise masks as in Greff et al. (2019).
+
+Finally, omitting subscripts, the full generative model can be written as
+
+$$
+p _ { \theta } ( \mathbf { x } ) = \iint p _ { \theta } ( \mathbf { x } \mid \mathbf { z } ^ { c } , \mathbf { z } ^ { m } ) p _ { \theta } ( \mathbf { z } ^ { c } \mid \mathbf { z } ^ { m } ) p _ { \theta } ( \mathbf { z } ^ { m } ) \mathrm { d } \mathbf { z } ^ { m } \mathrm { d } \mathbf { z } ^ { c } ,
+$$
+
+where we assume that all conditional distributions are Gaussian. The Gaussian components of the image likelihood have a fixed scalar standard deviation $\sigma _ { x } ^ { 2 }$ . We refer to this model as GENESIS. To investigate whether separate latents for masks and component appearances are necessary for decomposition, we consider a simplified model, GENESIS-S, with a single latent variable per component,
+
+$$
+p _ { \theta } ( \mathbf { z } _ { 1 : K } ) = \prod _ { k = 1 } ^ { K } p _ { \theta } ( \mathbf { z } _ { k } \mid \mathbf { z } _ { 1 : k - 1 } ) .
+$$
+
+In this case, $\mathbf { z } _ { k }$ takes the role of $\mathbf { z } _ { k } ^ { c }$ in Equation (3) and of $\mathbf { z } _ { k } ^ { m }$ in Equation (4), while Equation (2) is no longer necessary.
+
+Approximate posterior We amortise inference by using an approximate posterior distribution with parameters $\phi$ and a structure similar to the generative model. The full approximate posterior reads as follows,
+
+$$
+\begin{array} { r l } & { \displaystyle q _ { \phi } ( \mathbf { z } _ { 1 : K } ^ { c } , \mathbf { z } _ { 1 : K } ^ { m } \mid \mathbf { x } ) = q _ { \phi } ( \mathbf { z } _ { 1 : K } ^ { m } \mid \mathbf { x } ) q _ { \phi } ( \mathbf { z } _ { 1 : K } ^ { c } \mid \mathbf { x } , \mathbf { z } _ { 1 : K } ^ { m } ) , \quad \mathrm { w h e r e } } \\ & { \displaystyle q _ { \phi } ( \mathbf { z } _ { 1 : K } ^ { m } \mid \mathbf { x } ) = \prod _ { k = 1 } ^ { K } q _ { \phi } \big ( \mathbf { z } _ { k } ^ { m } \mid \mathbf { x } , \mathbf { z } _ { 1 : k - 1 } ^ { m } \big ) , \quad \mathrm { a n d } \quad q _ { \phi } ( \mathbf { z } _ { 1 : K } ^ { c } \mid \mathbf { x } , \mathbf { z } _ { 1 : K } ^ { m } ) = \prod _ { k = 1 } ^ { K } q _ { \phi } ( \mathbf { z } _ { k } ^ { c } \mid \mathbf { x } , \mathbf { z } _ { 1 : k } ^ { m } ) , } \end{array}
+$$
+
+with the dependence on the prior, but we have n $\mathbf { z } _ { 1 : k - 1 } ^ { m }$ realised by an RNN stigated this option. $\mathrm { R } _ { \phi }$ . The RNN could, in principle, be shared withll conditional distributions are Gaussian. For GENESIS-S, the approximate posterior takes the form $\begin{array} { r } { q _ { \phi } ( \mathbf { z } _ { 1 : K } \mid \mathbf { x } ) = \prod _ { k = 1 } ^ { K } q _ { \phi } ( \mathbf { z } _ { k } \mid \mathbf { x } , \mathbf { z } _ { 1 : k - 1 } ) } \end{array}$ .
+
+![](images/707b6d2abdfe8f023bd2c778710cf715a0d7f1a4f5324348d465dac32ae78e8d.jpg)  
+Figure 2: Graphical model of GENESIS compared to related methods. $N$ denotes the number of refinement iterations in IODINE. Unlike the other methods, both GENESIS variants explicitly model dependencies between scene components.
+
+Learning GENESIS can be trained by maximising the evidence lower bound (ELBO) on the logmarginal likelihood $\log p _ { \theta } ( \mathbf { x } )$ , given by
+
+$$
+{ \begin{array} { r l } & { { \mathcal { L } } _ { \mathrm { E L B O } } ( \mathbf { x } ) = \mathbb { E } _ { q _ { \phi } ( \mathbf { z } ^ { c } , \mathbf { z } ^ { m } | \mathbf { x } ) } \left[ \log \frac { p _ { \theta } ( \mathbf { x } \mid \mathbf { z } ^ { c } , \mathbf { z } ^ { m } ) p _ { \theta } ( \mathbf { z } ^ { c } \mid \mathbf { z } ^ { m } ) p _ { \theta } ( \mathbf { z } ^ { m } ) } { q _ { \phi } ( \mathbf { z } ^ { c } \mid \mathbf { z } ^ { m } , \mathbf { x } ) q _ { \phi } ( \mathbf { z } ^ { m } \mid \mathbf { x } ) } \right] } \\ & { \qquad = \mathbb { E } _ { q _ { \phi } ( \mathbf { z } ^ { c } , \mathbf { z } ^ { m } | \mathbf { x } ) } [ \log p _ { \theta } ( \mathbf { x } \mid \mathbf { z } ^ { c } , \mathbf { z } ^ { m } ) ] - \operatorname { K L } \left( q _ { \phi } ( \mathbf { z } ^ { c } , \mathbf { z } ^ { m } \mid \mathbf { x } ) \mid \mid p _ { \theta } ( \mathbf { z } ^ { c } , \mathbf { z } ^ { m } ) \right) . } \end{array} }
+$$
+
+However, this often leads to a strong emphasis on the likelihood term, while allowing the marginal approximate posterior $q _ { \phi } ( \mathbf { z } ) = \mathbb { E } _ { p _ { \mathrm { d a t a } } ( \mathbf { x } ) } [ q _ { \phi } ( \mathbf { z } \mid \mathbf { x } ) ]$ to drift away from the prior distribution, hence increasing the KL-divergence. This also decreases the quality of samples drawn from the model. To prevent this behaviour, we use the Generalised ELBO with Constrained Optimisation (GECO) objective from Rezende $\&$ Viola (2018) instead, which changes the learning problem to minimising the KL-divergence subject to a reconstruction constraint. Let $C \in \mathbb { R }$ be the minimum allowed reconstruction log-likelihood, GECO then uses Lagrange multipliers to solve the following problem,
+
+$$
+\begin{array} { r l } & { \theta ^ { \star } , \phi ^ { \star } = \arg \underset { \theta , \phi } { \operatorname* { m i n } } \mathrm { K L } \left( q _ { \phi } ( \mathbf { z } ^ { c } , \mathbf { z } ^ { m } \mid \mathbf { x } ) \mid \mid p _ { \theta } ( \mathbf { z } ^ { c } , \mathbf { z } ^ { m } ) \right) } \\ & { \quad \quad \quad \mathrm { s u c h t h a t } \quad \mathbb { E } _ { q _ { \phi } ( \mathbf { z } ^ { c } , \mathbf { z } ^ { m } \mid \mathbf { x } ) } [ \log p _ { \theta } ( \mathbf { x } \mid \mathbf { z } ^ { c } , \mathbf { z } ^ { m } ) ] \ge C . } \end{array}
+$$
+
+# 4 EXPERIMENTS
+
+In this section, we present qualitative and quantitative results on coloured Multi-dSprites (Burgess et al., 2019), the “rooms-ring-camera” dataset from $G Q N$ (Eslami et al., 2018) and the ShapeStacks dataset (Groth et al., 2018). We use an image resolution of 64-by-64 for all experiments. The number of components is set to $K = 5$ , $K = 7$ , and $K = 9$ for Multi-dSprites, GQN, and ShapeStacks, respectively. More details about the datasets are provided in Appendix A. Implementation and training details of all models are described in Appendix B.
+
+# 4.1 COMPONENT-WISE SCENE GENERATION
+
+Unlike previous works, GENESIS has an autoregressive prior to capture intricate dependencies between scene components. Modelling these relationships is necessary to generate coherent scenes. For example, different parts of the background need to fit together; we do not want to create components such as the sky several times; and several physical objects cannot be in the same location. GENESIS is able to generate novel scenes by sequentially sampling scene components from the prior and conditioning each new component on those that have been generated during previous steps.
+
+After training GENESIS and MONet on the GQN dataset, Figure 3 shows the component-bycomponent generation process of novel scenes, corresponding to drawing samples from the respective prior distributions. More examples of generated scenes are shown in Figure 6, Appendix D. With GENESIS, either an object in the foreground or a part of the background is generated at every step and these components fit together to make up a semantically consistent scene that looks similar to the training data. MONet, though, generates random artefacts at every step that do not form a sensible scene. These results are striking but not surprising: MONet was not designed for scene generation. The need for such a model is why we developed GENESIS.
+
+![](images/dd3b4f97277bcb2cd8347c9647b19cef2e8ea4f91fdf0a745718bfa04ed79560.jpg)  
+Figure 3: Component-by-component scene generation with GENESIS and MONet after training on the GQN dataset. The first pane shows the final scene and the subsequent panes show the components generated at each step. GENESIS first generates the sky and the floor, followed by individual objects, and finally distinct parts of the wall in the background to compose a coherent scene. MONet, in contrast, only generates incomplete components that do not fit together.
+
+Notably, GENESIS pursues a consistent strategy for scene generation: Step one generates the floor and the sky, defining the layout of the scene. Steps two to four generate individual foreground objects. Some of these slots remain empty if less than three objects are present in the scene. The final three steps generate the walls in the background. We conjecture that this strategy evolves during training as the floor and sky constitute large and easy to model surfaces that have a strong impact on the reconstruction loss. Finally, we observe that some slots contain artefacts of the sky at the top of the wall boundaries. We conjecture this is due to the fact that the mask decoder does not have skip connections as typically used in segmentation networks, making it difficult for the model to predict sharp segmentation boundaries. Scenes generated by GENESIS-S are shown in Figure 8 and Figure 9, Appendix D. While GENESIS-S does separate the foreground objects from the background, it generates them in one step and the individual background components are not very interpretable.
+
+# 4.2 INFERENCE OF SCENE COMPONENTS
+
+Like MONet and IODINE, which were designed for unsupervised scene decomposition, GENESIS is also able to segment scenes into meaningful components. Figure 4 compares the decomposition of two images from the GQN dataset with GENESIS and MONet. Both models follow a similar decomposition strategy, but MONet fails to disambiguate one foreground object in the first example and does not reconstruct the background in as much detail in the second example. In Appendix E, Figure 10 illustrates the ability of both methods to disambiguate objects of the same colour and Figure 11 shows scene decomposition with GENESIS-S.
+
+Following Greff et al. (2019), we quantify segmentation performance with the Adjusted Rand Index (ARI) of pixels overlapping with ground truth foreground objects. We computed the ARI on 300 random images from the ShapeStacks test set for five models trained with different random seeds. GENESIS achieves an ARI of $0 . 7 3 \pm 0 . 0 3$ which is better than $0 . 6 3 \pm 0 . 0 7$ for MONet. This metric, however, does not penalise objects being over-segmented, which can give a misleading impression with regards to segmentation quality. This is illustrated in Figure 13, Appendix E.
+
+Inspired by Arbelaez et al. (2010), we thus propose to use the segmentation covering (SC) of the ground truth foreground objects by the predicted masks. This involves taking a weighted mean over mask pairs, putting a potentially undesirable emphasis on larger objects. We therefore also consider taking an unweighted mean $\mathrm { ( m S C ) }$ . For the same 300 images from the ShapeStacks test set and five different random seeds, GENESIS (SC: $0 . 6 4 \pm 0 . 0 8$ , mSC: $0 . 6 0 \pm 0 . 0 9 )$ again outperforms MONet (SC: $0 . 5 2 \pm 0 . 0 9$ , mSC: $0 . 4 9 \pm 0 . 0 9 )$ . More details are provided in Appendix C.
+
+![](images/514d1e5385be20062948dc181b2816c9bec48e858e8110fb06fb558d6d719d9b.jpg)  
+Figure 4: Step-by-step decomposition of the same scene from GQN with GENESIS and MONet. Unlike MONet, GENESIS clearly differentiates individual objects in the first example. In the second example, GENESIS captures the fine-grained pattern of the wall in the background better than MONet.
+
+# 4.3 EVALUATION OF UNSUPERVISED REPRESENTATION UTILITY
+
+Using a subset of the available labelled training images from ShapeStacks, we train a set of classifiers on the representations learned by GENESIS and several baselines to evaluate how well these representations capture the ground truth scene state. In particular, we consider three tasks: (1) Is a tower stable or not? (2) What is the tower’s height in terms of the number of blocks? (3) What is the camera viewpoint (out of 16 possibilities)? Tower stability is a particularly interesting property as it depends on in fine-grained object information and the relative positioning of objects. We selected the third task as learning scene representations from different views has previously been prominently explored in Eslami et al. (2018). We compare GENESIS and GENESIS-S against three baselines: MONet, a VAE with a spatial broadcast decoder (BD-VAE) and a VAE with a deconvolutional decoder (DC-VAE). The results are summarised in Table 1. The architectural details of the baselines are described in Appendix B.2 and Appendix B.3. The implementation details of the classifiers are provided in Appendix B.5.
+
+Both GENESIS and GENESIS-S perform better than than the baselines at predicting tower stability and their accuracies on predicting the height of the towers is only outperformed by MONet. We conjecture that MONet benefits here by its deterministic segmentation network. Overall, this corroborates the intuition that object-centric representations are indeed beneficial for these tasks which focus on the foreground objects. We observe that the BD-VAE does better than the DC-VAE on all three tasks, reflecting the motivation behind its design which is aimed at better disentangling the underlying factors of variation in the data (Watters et al., 2019b). All models achieve a high accuracy at predicting the camera view. Finally, we note that none of models reach the stability prediction accuracies reported in Groth et al. (2018) which were obtained with an Inception-v4 classifier (Szegedy et al., 2017). This is not surprising considering that only a subset the training images is used for training the classifiers without data augmentation and at a reduced resolution.
+
+Table 1: Classification accuracy in $\%$ on the test sets of the ShapeStacks tasks.   
+
+<table><tr><td>Task</td><td>GENESIS</td><td>GENESIS-S</td><td>MONet</td><td>BD-VAE</td><td>DC-VAE</td><td>Random</td></tr><tr><td>Stability</td><td>64.0</td><td>63.2</td><td>59.6</td><td>60.1</td><td>59.0</td><td>50.0</td></tr><tr><td>Height</td><td>80.3</td><td>80.8</td><td>88.4</td><td>78.6</td><td>67.5</td><td>22.8</td></tr><tr><td>View</td><td>99.3</td><td>99.7</td><td>99.5</td><td>99.7</td><td>99.1</td><td>6.25</td></tr></table>
+
+# 4.4 QUANTIFYING SAMPLE QUALITY
+
+In order to quantify the quality of generated scenes, Table 2 summarises the Fréchet Inception Distances (FIDs) (Heusel et al., 2017) between 10,000 images generated by GENESIS as well several baselines and 10,000 images from the Multi-dSprites and the GQN test sets, respectively. The two GENESIS variants achieve the best FID on both datasets. While GENESIS-S performs better than GENESIS on GQN, Figure 8 and Figure 9 in Appendix D show that individual scene components are less interpretable and that intricate background patterns are generated at the expense of sensible foreground objects. It is not surprising that the FIDs for MONet are relatively large given that it was not designed for generating scenes. Interestingly, the DC-VAE achieves a smaller FID on GQN than the BD-VAE. This is surprising given that the BD-VAE representations are more useful for the ShapeStacks classification tasks. Given that the GQN dataset and ShapeStacks are somewhat similar in structure and appearance, this indicates that while FID correlates with perceptual similarity, it does not necessarily correlate with the general utility of the learned representations for downstream tasks. We include scenes sampled from the BD-VAE and the DC-VAE in Figure 7, Appendix D, where we observe that the DC-VAE models the background fairly well while foreground objects are blurry.
+
+Table 2: Fréchet Inception Distances for GENESIS and baselines on GQN.   
+
+<table><tr><td>Dataset</td><td>GENESIS</td><td>GENESIS-S</td><td>MONet</td><td>BD-VAE</td><td>DC-VAE</td></tr><tr><td>Multi-dSprites</td><td>24.9</td><td>28.2</td><td>92.7</td><td>89.8</td><td>100.5</td></tr><tr><td>GQN</td><td>80.5</td><td>70.2</td><td>176.4</td><td>145.5</td><td>82.5</td></tr></table>
+
+# 5 CONCLUSIONS
+
+In this work, we propose a novel object-centric latent variable model of scenes called GENESIS. We show that GENESIS is, to the best of our knowledge, the first unsupervised model to both decompose rendered 3D scenes into semantically meaningful constituent parts, while at the same time being able to generate coherent scenes in a component-wise fashion. This is achieved by capturing relationships between scene components with an autoregressive prior that is learned alongside a computationally efficient sequential inference network, setting GENESIS apart from prior art. Regarding future work, an interesting challenge is to scale GENESIS to more complex datasets and to employ the model in robotics or reinforcement learning applications. To this end, it will be necessary to improve reconstruction and sample quality, reduce computational cost, and to scale the model to higher resolution images. Another potentially promising research direction is to adapt the formulation to only model parts of the scene that are relevant for a certain task.
+
+# ACKNOWLEDGMENTS
+
+This research was supported by an EPSRC Programme Grant (EP/M019918/1), an EPSRC DTA studentship, and a Google studentship. The authors would like to acknowledge the use of the University of Oxford Advanced Research Computing (ARC) facility in carrying out this work, http://dx.doi.org/10.5281/zenodo.22558, and the use of Hartree Centre resources. The authors would like to thank Yizhe Wu for his help with re-implementing MONet, Oliver Groth for his support with the GQN and ShapeStacks datasets, and Rob Weston for proof reading the paper.
+
+# REFERENCES
+
+Relja Arandjelovic and Andrew Zisserman. Object Discovery with a Copy-Pasting GAN. ´ arXiv preprint arXiv:1905.11369, 2019.
+
+Pablo Arbelaez, Michael Maire, Charless Fowlkes, and Jitendra Malik. Contour Detection and Hierarchical Image Segmentation. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2010.
+
+Samaneh Azadi, Deepak Pathak, Sayna Ebrahimi, and Trevor Darrell. Compositional GAN: Learning Image-Conditional Binary Composition. arXiv preprint arXiv:1807.07560, 2019.
+
+Rianne van den Berg, Leonard Hasenclever, Jakub M Tomczak, and Max Welling. Sylvester Normalizing Flows for Variational Inference. Conference on Uncertainty in Artificial Intelligence, 2018.
+
+Adam Bielski and Paolo Favaro. Emergence of Object Segmentation in Perturbed Generative Models. arXiv preprint arXiv:1905.12663, 2019.
+
+Andrew Brock, Jeff Donahue, and Karen Simonyan. Large Scale GAN Training for High Fidelity Natural Image Synthesis. arXiv preprint arXiv:1809.11096, 2018.
+
+Christopher P Burgess, Loic Matthey, Nicholas Watters, Rishabh Kabra, Irina Higgins, Matt Botvinick, and Alexander Lerchner. MONet: Unsupervised Scene Decomposition and Representation. arXiv preprint arXiv:1901.11390, 2019.
+
+Mickaël Chen, Thierry Artières, and Ludovic Denoyer. Unsupervised Object Segmentation by Redrawing. arXiv preprint arXiv:1905.13539, 2019.
+
+Djork-Arné Clevert, Thomas Unterthiner, and Sepp Hochreiter. Fast and Accurate Deep Network Learning by Exponential Linear Units (ELUs). International Conference on Learning Representations, 2016.
+
+Pierre Comon. Independent Component Analysis. In J-L.Lacoume (ed.), Higher-Order Statistics, pp. 29–38. Elsevier, 1992.
+
+Eric Crawford and Joelle Pineau. Spatially Invariant Unsupervised Object Detection with Convolutional Neural Networks. AAAI Conference on Artificial Intelligence, 2019.
+
+Yann N Dauphin, Angela Fan, Michael Auli, and David Grangier. Language Modeling with Gated Convolutional Networks. International Conference on Machine Learning, 2017.
+
+SM Ali Eslami, Nicolas Heess, Theophane Weber, Yuval Tassa, David Szepesvari, Geoffrey E Hinton, et al. Attend, Infer, Repeat: Fast Scene Understanding with Generative Models. Neural Information Processing Systems, 2016.
+
+SM Ali Eslami, Danilo Jimenez Rezende, Frederic Besse, Fabio Viola, Ari S Morcos, Marta Garnelo, Avraham Ruderman, Andrei A Rusu, Ivo Danihelka, Karol Gregor, et al. Neural Scene Representation and Rendering. Science, 2018.
+
+Karl Friston. A Theory of Cortical Responses. Philosophical Transactions of the Royal Society B: Biological Sciences, 360(1456):815–836, 2005.
+
+Xavier Glorot, Antoine Bordes, and Yoshua Bengio. Deep Sparse Rectifier Neural Networks. International Conference on Artificial Intelligence and Statistics, 2011.
+
+Klaus Greff, Antti Rasmus, Mathias Berglund, Tele Hao, Harri Valpola, and Jürgen Schmidhuber. Tagger: Deep Unsupervised Perceptual Grouping. Neural Information Processing Systems, 2016.
+
+Klaus Greff, Sjoerd van Steenkiste, and Jürgen Schmidhuber. Neural Expectation Maximization. Neural Information Processing Systems, 2017.
+
+Klaus Greff, Raphaël Lopez Kaufmann, Rishab Kabra, Nick Watters, Chris Burgess, Daniel Zoran, Loic Matthey, Matthew Botvinick, and Alexander Lerchner. Multi-Object Representation Learning with Iterative Variational Inference. International Conference on Machine Learning, 2019.
+
+Karol Gregor, Danilo Jimenez Rezende, Frederic Besse, Yan Wu, Hamza Merzic, and Aaron van den Oord. Shaping Belief States with Generative Environment Models for RL. arXiv preprint arXiv:1906.09237, 2019.
+
+Kalanit Grill-Spector and Rafael Malach. The Human Visual Cortex. Annual Review of Neuroscience, 27(1):649–677, 2004.
+
+Oliver Groth, Fabian B Fuchs, Ingmar Posner, and Andrea Vedaldi. ShapeStacks: Learning VisionBased Physical Intuition for Generalised Object Stacking. European Conference on Computer Vision, 2018.
+
+David Ha and Jürgen Schmidhuber. World Models. Neural Information Processing Systems, 2018.
+
+Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. GANs Trained by a Two Time-Scale Update Rule Converge to a Local Nash Equilibrium. Neural Information Processing Systems, 2017.
+
+Sepp Hochreiter and Jürgen Schmidhuber. Long Short-Term Memory. Neural Computation, 1997.
+
+Jonathan Huang and Kevin Murphy. Efficient Inference in Occlusion-Aware Generative models of Images. arXiv preprint arXiv:1511.06362, 2015.
+
+D. H. Hubel and T. N. Wiesel. Receptive Fields and Functional Architecture of Monkey Striate Cortex. The Journal of Physiology, 195(1):215–243, 1968.
+
+Sergey Ioffe and Christian Szegedy. Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift. International Conference on Machine Learning, 2015.
+
+Michael I Jordan, Zoubin Ghahramani, Tommi S Jaakkola, and Lawrence K Saul. An Introduction to Variational Methods for Graphical Models. Machine Learning, 37(2):183–233, 1999.
+
+Diederik P Kingma and Jimmy Ba. Adam: A Method for Stochastic Optimization. International Conference on Learning Representations, 2015.
+
+Diederik P Kingma and Max Welling. Auto-Encoding Variational Bayes. International Conference on Learning Representations, 2014.
+
+Adam Kosiorek, Hyunjik Kim, Yee Whye Teh, and Ingmar Posner. Sequential Attend, Infer, Repeat: Generative Modelling of Moving Objects. Neural Information Processing Systems, 2018.
+
+Adam R Kosiorek, Sara Sabour, Yee Whye Teh, and Geoffrey E Hinton. Stacked Capsule Autoencoders. arXiv preprint arXiv:1906.06818, 2019.
+
+Loic Matthey, Irina Higgins, Demis Hassabis, and Alexander Lerchner. dSprites: Disentanglement Testing Sprites Dataset. https://github.com/deepmind/dsprites-dataset/, 2017.
+
+Bruno A. Olshausen and David J. Field. Emergence of Simple-Cell Receptive Field Properties by Learning a Sparse Code for Natural Images. Nature, 381:607–609, 1996.
+
+Niki Parmar, Ashish Vaswani, Jakob Uszkoreit, Łukasz Kaiser, Noam Shazeer, Alexander Ku, and Dustin Tran. Image Transformer. International Conference on Machine Learning, 2018.
+
+Rajesh P. N. Rao and Dana H. Ballard. Predictive Coding in the Visual Cortex: A Functional Interpretation of Some Extra-Classical Receptive-Field Effects. Nature Neuroscience, 2(1):79– 87, 1999.
+
+Danilo Jimenez Rezende and Fabio Viola. Taming VAEs. arXiv preprint arXiv:1810.00597, 2018.
+
+Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic Backpropagation and Approximate Inference in Deep Generative Models. International Conference on Machine Learning, 2014.
+
+Lukasz Romaszko, Christopher KI Williams, Pol Moreno, and Pushmeet Kohli. Vision-as-InverseGraphics: Obtaining a Rich 3D Explanation of a Scene from a Single Image. In IEEE International Conference on Computer Vision, 2017.
+
+Adam Santoro, David Raposo, David G. T. Barrett, Mateusz Malinowski, Razvan Pascanu, Peter W. Battaglia, and Timothy P. Lillicrap. A Simple Neural Network Module for Relational Reasoning. Neural Information Processing Systems, 2017.
+
+Christian Szegedy, Sergey Ioffe, Vincent Vanhoucke, and Alexander A Alemi. Inception-V4, Inception-Resnet and the Impact of Residual Connections on Learning. AAAI Conference on Artificial Intelligence, 2017.
+
+Naftali Tishby, Fernando C Pereira, and William Bialek. The Information Bottleneck Method. arXiv preprint arXiv:physics/0004057, 2000.
+
+Sjoerd van Steenkiste, Michael Chang, Klaus Greff, and Jürgen Schmidhuber. Relational Neural Expectation Maximization: Unsupervised Discovery of Objects and their Interactions. arXiv preprint arXiv:1802.10353, 2018a.
+
+Sjoerd van Steenkiste, Karol Kurach, and Sylvain Gelly. A Case for Object Compositionality in Deep Generative Models of Images. NeurIPS Workshop on Modeling the Physical World: Learning, Perception, and Control, 2018b.
+
+Sjoerd van Steenkiste, Francesco Locatello, Jurgen Schmidhuber, and Olivier Bachem. Are Disentangled Representations Helpful for Abstract Visual Reasoning? arXiv preprint arXiv:1905.12506, 2019.
+
+Brian A. Wandell. Foundations of Vision. Sinauer Associates, 1995.
+
+Nicholas Watters, Loic Matthey, Matko Bosnjak, Christopher P Burgess, and Alexander Lerchner. COBRA: Data-Efficient Model-Based RL through Unsupervised Object Discovery and CuriosityDriven Exploration. arXiv preprint arXiv:1905.09275, 2019a.
+
+Nicholas Watters, Loic Matthey, Christopher P Burgess, and Alexander Lerchner. Spatial Broadcast Decoder: A Simple Architecture for Learning Disentangled Representations in VAEs. arXiv preprint arXiv:1901.07017, 2019b.
+
+Jiajun Wu, Erika Lu, Pushmeet Kohli, Bill Freeman, and Josh Tenenbaum. Learning to See Physics via Visual De-Animation. Neural Information Processing Systems, 2017a.
+
+Jiajun Wu, Joshua B Tenenbaum, and Pushmeet Kohli. Neural Scene De-rendering. IEEE Conference on Computer Vision and Pattern Recognition, pp. 699–707, 2017b.
+
+Kun Xu, Chongxuan Li, Jun Zhu, and Bo Zhang. Multi-Objects Generation with Amortized Structural Regularization. Neural Information Processing Systems, 2018.
+
+Zhenjia Xu, Zhijian Liu, Chen Sun, Kevin Murphy, William T Freeman, Joshua B Tenenbaum, and Jiajun Wu. Unsupervised Discovery of Parts, Structure, and Dynamics. arXiv preprint arXiv:1903.05136, 2019.
+
+# A DATASETS
+
+Multi-dSprites (Burgess et al., 2019) Images contain between one and four randomly selected “sprites” from Matthey et al. (2017), available at https://github.com/deepmind/ dsprites-dataset. For each object and the background, we randomly select one of five different, equally spread values for each of the three colour channels and generate 70,000 images. We set aside 10,000 for validation and testing each. The script for generating this data will be released with the rest of our code.
+
+GQN (Eslami et al., 2018) The “rooms-ring-camera” dataset includes simulated 3D scenes of a square room with different floor and wall textures, containing one to three objects of various shapes and sizes. It can be downloaded from https://github.com/deepmind/gqn-datasets.
+
+ShapeStacks (Groth et al., 2018) Images show simulated block towers of different heights (two to six blocks). Individual blocks can have different shapes, sizes, and colours. Scenes have annotations for: stability of the tower (binary), number of blocks (two to six), properties of individual blocks, locations in the tower of centre-of-mass violations and planar surface violations, wall and floor textures (five each), light presets (five), and camera view points (sixteen). More details about the dataset and download links can be found at https://shapestacks.robots.ox.ac.uk/.
+
+# B IMPLEMENTATION DETAILS
+
+# B.1 GENESIS ARCHITECTURE
+
+We use the architecture from Berg et al. (2018) to encode and decode $\mathbf { z } _ { k } ^ { m }$ with the only modification of applying batch normalisation (Ioffe & Szegedy, 2015) before the GLU non-linearities (Dauphin et al., 2017). The convolutional layers in the encoder and decoder have five layers with size-5 kernels, strides of [1, 2, 1, 2, 1], and filter sizes of [32, 32, 64, 64, 64] and [64, 32, 32, 32, 32], respectively. Fully-connected layers are used at the lowest resolution.
+
+The encoded image is passed to a long short-term memory (LSTM) cell (Hochreiter & Schmidhuber, 1997) followed by a linear layer to compute the mask latents $\mathbf { z } _ { k } ^ { m }$ of size 64. The LSTM state size is twice the latent size. Importantly, unlike the analogous counterpart in MONet, the decoding of $\mathbf { z } _ { k } ^ { m }$ is performed in parallel. The autoregressive prior $\overline { { p } } _ { \theta } \left( \mathbf { z } _ { k } ^ { m } \mid \mathbf { z } _ { 1 : k - 1 } ^ { m } \right)$ is implemented as an LSTM with 256 units. The conditional distribution $p _ { \theta } ( \mathbf { z } _ { k } ^ { c } \mid \mathbf { z } _ { k } ^ { m } )$ is parameterised by a multilayer perceptron (MLP) with two hidden layers, 256 units per layer, and ELUs (Clevert et al., 2016). We use the same component VAE featuring a spatial broadcast decoder as MONet to encode and decode $z _ { k } ^ { c }$ , but we replace RELUs (Glorot et al., 2011) with ELUs.
+
+For GENESIS-S, as illustrated in Figure 5, the encoder of $\mathbf { z } _ { k }$ is the same as for $\mathbf { z } _ { k } ^ { m }$ above and the decoder from Berg et al. (2018) is again used to compute the mixing probabilities. However, GENESIS-S also has a second decoder with spatial broadcasting to obtain the scene components $\mathbf { x } _ { k }$ from $\mathbf { z } _ { k }$ . We found the use of two different decoders to be important for GENESIS-S in order for the model to decompose the input.
+
+![](images/fbf7d415b33ea3ead95520bb83a52a942598dcdcea897aaa0836d75a64f0a98c.jpg)  
+Figure 5: GENESIS-S overview. Given an image x, an encoder and an RNN compute latent variables $\mathbf { z } _ { k }$ . These are decoded to directly obtain the mixing probabilities $\pi _ { k }$ and the scene components $\mathbf { x } _ { k }$ .
+
+# B.2 MONET BASELINES
+
+We followed the provided architectural details described in Burgess et al. (2019). Regarding unspecified details, we employ an attention network with [32, 32, 64, 64, 64] filters in the encoder and the reverse in the decoder. Furthermore, we normalise the mask prior with a softmax function to compute the KL-divergence between mask posterior and prior distributions.
+
+# B.3 VAE BASELINES
+
+Both the BD-VAE and the DC-VAE have a latent dimensionality of 64 and the same encoder as in Berg et al. (2018). The DC-VAE also uses the decoder from Berg et al. (2018). The BD-VAE has the same spatial broadcast decoder with ELUs as GENESIS, but with twice the number of filters to enable a better comparison.
+
+# B.4 OPTIMISATION
+
+The scalar standard deviation of the Gaussian image likelihood components is set to $\sigma _ { x } = 0 . 7$ . We use GECO (Rezende & Viola, 2018) to balance the reconstruction and KL divergence terms in the loss function. The goal for the reconstruction error is set to 0.5655, multiplied by the image dimensions and number of colour channels. We deliberately choose a comparatively weak reconstruction constraint for the GECO objective to emphasise KL minimisation and sample quality. For the remainining GECO hyperparameters, the default value of $\alpha = 0 . 9 9$ is used and the step size for updating $\beta$ is set to $1 0 ^ { - 5 }$ . We increase the step size to $1 0 ^ { - 4 }$ when the reconstruction constraint is satisfied to accelerate optimisation as $\beta$ tended to undershoot at the beginning of training.
+
+All models are trained for $5 * 1 0 ^ { 5 }$ iterations with a batch size of 32 using the ADAM optimiser (Kingma & Ba, 2015) and a learning rate of $1 0 ^ { - 4 }$ . With these settings, training GENESIS takes about two days on a single GPU. However, we expect performance to improve with further training. This particularly extends to training GENESIS on ShapeStacks where $5 * 1 0 ^ { 5 }$ training iterations are not enough to achieve good sample quality.
+
+# B.5 SHAPESTACKS CLASSIFIERS
+
+Multilayer perceptrons (MLPs) with one hidden layer, 512 units, and ELU activations are used for classification. The classifiers are trained for 100 epochs on 50,000 labelled examples with a batch size of 128 using a cross-entropy loss, the ADAM optimiser, and a learning rate of $1 0 ^ { - 4 }$ . As inputs to the classifiers, we concatenate $\mathbf { z } _ { k } ^ { m }$ and $\mathbf { z } _ { k } ^ { c }$ for GENESIS, $\mathbf { z } _ { k }$ for GENESIS-S, and the component VAE latents for the two MONet variants.
+
+# C SEGMENTATION COVERING
+
+Following Arbelaez et al. (2010), the segmentation covering (SC) is based on the intersection over union (IOU) between pairs of segmentation masks from two sets $S$ and $S ^ { \prime }$ . In this work, we consider $S$ to be the segmentation masks of the ground truth foreground objects and $S ^ { \prime }$ to be the predicted segmentation masks. The covering of $S$ by $S ^ { \prime }$ is defined as:
+
+$$
+C ( S ^ { \prime }  S ) = \frac { 1 } { \sum _ { R \in S } | R | } \sum _ { R \in S } | R | \operatorname* { m a x } _ { R ^ { \prime } \in S ^ { \prime } } \operatorname { I O U } ( R , R ^ { \prime } ) ,
+$$
+
+where $| R |$ denotes the number of pixels belonging to mask $R$ . Note that this formulation is slightly more general than the one in Arbelaez et al. (2010) which assumes that masks in $S$ are nonoverlapping and cover the entire image. The above takes a weighted mean over IOU values, proportional to the number of pixels of the masks being covered. To give equal importance to masks of different sizes, we also consider taking an unweighted mean (mSC):
+
+$$
+C _ { m } ( S ^ { \prime }  S ) = \frac { 1 } { | S | } \sum _ { R \in S } \operatorname* { m a x } _ { R ^ { \prime } \in S ^ { \prime } } \operatorname { I O U } ( R , R ^ { \prime } ) ,
+$$
+
+where $| S |$ denotes the number of non-empty masks in $S$ . Importantly and unlike the ARI, both segmentation covering variations penalise the over-segmentation of ground truth objects as this decreases the IOU for a pair of masks. This is illustrated in Figure 13, Appendix E.
+
+# D COMPONENT-WISE SCENE GENERATION - GQN
+
+![](images/92e97ef3885b0aa4ebfc85243083f1644c63934a47d2f4e36bf2e6f2659eec48.jpg)  
+Figure 6: Randomly selected scenes generated by GENESIS and MONet after training on the GQN dataset. Images sampled from GENESIS contain clearly distinguishable foreground objects and backgrounds. Samples from MONet, however, are mostly incoherent.
+
+![](images/99adb7fedf7331d9a2c2fcbbd5954b8b9dc75324dd40460dae3ae2468d1111b5.jpg)  
+Figure 7: Randomly selected scenes generated by the BD-VAE and the DC-VAE after training on the GQN dataset; shown for comparison. The DC-VAE generates decent scene backgrounds but foreground objects are blurry.
+
+![](images/0606440d9481eab1fe70105a952b7c379b9d5076a0b58f30b52e9fe33736082f.jpg)  
+Figure 8: Component-by-component scene generation with GENESIS-S after training on the GQN dataset. While GENESIS-S nominally achieves the best FID in Table 2, this appears to be due to the generation of high fidelity background patterns rather than appropriate foreground objects. Furthermore, unlike the components generated by GENESIS at every step in Figure 3, the components generated by GENESIS-S are not very interpretable.
+
+![](images/237513bd882ebf8e997b48c9184a362fec3284fa16e195dcb2aa63fc5b268350.jpg)  
+Figure 9: Randomly selected scenes generated by GENESIS-S after training on the GQN dataset.
+
+# E INFERENCE OF SCENE COMPONENTS
+
+![](images/09800ff9f138399ace17ccea3c16fd50580fb1ec9c407773fc40c1c044f78d07.jpg)  
+Figure 10: Step-by-step decomposition of a scene from GQN with GENESIS and MONet. Two objects with the same shape and colour are successfully identified by both models. While colour and texture are useful cues for decomposition, this example shows that both models perform something more useful than merely identifying regions of similar colour.
+
+![](images/347ee4a9456a67fcae7fce39b09cad3dd231fe956997b0deaded7f32688565c7.jpg)  
+Figure 11: Step-by-step decomposition of the same scenes as in Figure 4 and Figure 10 with GENESIS-S. While the foreground objects are distinguished from the background, they are explained together in the first step. Subsequent steps reconstruct the background in a haphazard fashion.
+
+![](images/7ad08c18df8b6516fcc4b65dfef8b1b7f9c2509ee09412fb4fb4243cb831efd9.jpg)  
+Figure 12: A ShapeStacks tower is decomposed by GENESIS and MONet. Compared to the GQN dataset, both methods struggle to segment the foreground objects properly. GENESIS captures the purple shape and parts of the background wall in step $k = 4$ . MONet explains the green shape, the cyan shape, and parts of floor in step $k \ = \ 9$ . This is reflected in the foreground ARI and segmentation covering for GENESIS (ARI: 0.82, SC: 0.68, mSC: 0.58) and MONet (ARI: 0.39, SC: 0.26, mSC: 0.35); the latter being lower as the green and cyan shapes are not separated.
+
+![](images/774561359179c582699ce422039920296499d7047124e128a05ed57256226af0.jpg)  
+Figure 13: In this example, GENESIS (ARI: 0.83, SC: 0.83, mSC: 0.83) segments the four foreground objects properly. MONet (ARI: 0.89, SC: 0.47, mSC: 0.50), however, merges foreground objects and background again in steps $k = 2$ and $k = 9$ . Despite the inferior decomposition, the ARI for MONet is higher than for GENESIS. This is possible as the ARI does not penalise the over-segmentation of the foreground objects, highlighting its limitations for evaluating unsupervised instance segmentation. The segmentation covering, however, reflects the quality of the segmentatioin masks properly.

parse/train/BkxfaTVFwH/BkxfaTVFwH_content_list.json

@@ -0,0 +1,1814 @@
+[
+    {
+        "type": "text",
+        "text": "GENESIS: GENERATIVE SCENE INFERENCE AND SAMPLING WITH OBJECT-CENTRIC LATENT REPRESENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            751,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Martin Engelcke∗∇, Adam R. Kosiorek∇∆, Oiwi Parker Jones∇ & Ingmar Posner∇ ∇ Applied AI Lab, University of Oxford; ∆ Dept. of Statistics, University of Oxford ",
+        "bbox": [
+            186,
+            193,
+            772,
+            224
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            261,
+            544,
+            276
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Generative latent-variable models are emerging as promising tools in robotics and reinforcement learning. Yet, even though tasks in these domains typically involve distinct objects, most state-of-the-art generative models do not explicitly capture the compositional nature of visual scenes. Two recent exceptions, MONet and IODINE, decompose scenes into objects in an unsupervised fashion. Their underlying generative processes, however, do not account for component interactions. Hence, neither of them allows for principled sampling of novel scenes. Here we present GENESIS, the first object-centric generative model of rendered 3D scenes capable of both decomposing and generating scenes by capturing relationships between scene components. GENESIS parameterises a spatial GMM over images which is decoded from a set of object-centric latent variables that are either inferred sequentially in an amortised fashion or sampled from an autoregressive prior. We train GENESIS on several publicly available datasets and evaluate its performance on scene generation, decomposition, and semi-supervised learning. ",
+        "bbox": [
+            233,
+            292,
+            764,
+            487
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            515,
+            336,
+            530
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Task execution in robotics and reinforcement learning (RL) requires accurate perception of and reasoning about discrete elements in an environment. While supervised methods can be used to identify pertinent objects, it is intractable to collect labels for every scenario and task. Discovering structure in data—such as objects—and learning to represent data in a compact fashion without supervision are long-standing problems in machine learning (Comon, 1992; Tishby et al., 2000), often formulated as generative latent-variable modelling (e.g. Kingma & Welling, 2014; Rezende et al., 2014). Such methods have been leveraged to increase sample efficiency in RL (Gregor et al., 2019) and other supervised tasks (van Steenkiste et al., 2019). They also offer the ability to imagine environments for training (Ha & Schmidhuber, 2018). Given the compositional nature of visual scenes, separating latent representations into object-centric ones can facilitate fast and robust learning (Watters et al., 2019a), while also being amenable to relational reasoning (Santoro et al., 2017). Interestingly, however, state-of-the-art methods for generating realistic images do not account for this discrete structure (Brock et al., 2018; Parmar et al., 2018). ",
+        "bbox": [
+            174,
+            546,
+            825,
+            727
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "As in the approach proposed in this work, human visual perception is not passive. Rather it involves a creative interplay between external stimulation and an active, internal generative model of the world (Rao & Ballard, 1999; Friston, 2005). That this is necessary can be seen from the physiology of the eye, where the small portion of the visual field that can produce sharp images (fovea centralis) motivates the need for rapid eye movements (saccades) to build up a crisp and holistic percept of a scene (Wandell, 1995). In other words, what we perceive is largely a mental simulation of the external world. Meanwhile, work in computational neuroscience tells us that visual features (see, e.g., Hubel & Wiesel, 1968) can be inferred from the statistics of static images using unsupervised learning (Olshausen & Field, 1996). Experimental investigations further show that specific brain areas (e.g. LO) appear specialised for objects, for example responding more strongly to common objects than to scenes or textures, while responding only weakly to movement (cf. MT) (e.g., GrillSpector & Malach, 2004). ",
+        "bbox": [
+            174,
+            734,
+            825,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we are interested in probabilistic generative models that can explain visual scenes compositionally via several latent variables. This corresponds to fitting a probability distribution $p _ { \\theta } ( \\mathbf { x } )$ with parameters $\\theta$ to the data. The compositional structure is captured by $K$ latent variables so that $\\begin{array} { r } { p _ { \\theta } ( \\dot { \\mathbf { x } } ) = \\int p _ { \\theta } ( \\mathbf { x } \\mid \\mathbf { z } _ { 1 : K } ) p _ { \\theta } ( \\mathbf { z } _ { 1 : K } ) \\mathrm { d } \\mathbf { z } _ { 1 : K } } \\end{array}$ . Models from this family can be optimised using the variational auto-encoder (VAE) framework (Kingma & Welling, 2014; Rezende et al., 2014), by maximising a variational lower bound on the model evidence (Jordan et al., 1999). Burgess et al. (2019) and Greff et al. (2019) recently proposed two such models, MONet and IODINE, to decompose visual scenes into meaningful objects. Both works leverage an analysis-by-synthesis approach through the machinery of VAEs (Kingma & Welling, 2014; Rezende et al., 2014) to train these models without labelled supervision, e.g. in the form of ground truth segmentation masks. However, the models have a factorised prior that treats scene components as independent. Thus, neither provides an object-centric generation mechanism that accounts for relationships between constituent parts of a scene, e.g. two physical objects cannot occupy the same location, prohibiting the component-wise generation of novel scenes and restricting the utility of these approaches. Moreover, MONet embeds a convolutional neural network (CNN) inside of an recurrent neural network (RNN) that is unrolled for each scene component, which does not scale well to more complex scenes. Similarly, IODINE utilises a CNN within an expensive, gradient-based iterative refinement mechanism. ",
+        "bbox": [
+            174,
+            104,
+            825,
+            339
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Therefore, we introduce GENErative Scene Inference and Sampling (GENESIS) which is, to the best of our knowledge, the first object-centric generative model of rendered 3D scenes capable of both decomposing and generating scenes1. Compared to previous work, this renders GENESIS significantly more suitable for a wide range of applications in robotics and reinforcement learning. GENESIS achieves this by modelling relationships between scene components with an expressive, autoregressive prior that is learned alongside a sequential, amortised inference network. Importantly, sequential inference is performed in low-dimensional latent space, allowing all convolutional encoders and decoders to be run in parallel to fully exploit modern graphics processing hardware. ",
+        "bbox": [
+            174,
+            347,
+            825,
+            458
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We conduct experiments on three canonical and publicly available datasets: coloured Multi-dSprites (Burgess et al., 2019), the GQN dataset (Eslami et al., 2018), and ShapeStacks (Groth et al., 2018). The latter two are simulated 3D environments which serve as testing grounds for navigation and object manipulation tasks, respectively. We show both qualitatively and quantitatively that in contrast to prior art, GENESIS is able to generate coherent scenes while also performing well on scene decomposition. Furthermore, we use the scene annotations available for ShapeStacks to show the benefit of utilising general purpose, object-centric latent representations from GENESIS for tasks such as predicting whether a block tower is stable or not. ",
+        "bbox": [
+            174,
+            464,
+            825,
+            575
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Code and models are available at https://github.com/applied-ai-lab/genesis. ",
+        "bbox": [
+            174,
+            583,
+            799,
+            597
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            617,
+            344,
+            633
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Structured Models Several methods leverage structured latent variables to discover objects in images without direct supervision. CST-VAE (Huang & Murphy, 2015), AIR (Eslami et al., 2016), SQAIR (Kosiorek et al., 2018), and SPAIR (Crawford & Pineau, 2019) use spatial attention to partition scenes into objects. TAGGER (Greff et al., 2016), NEM (Greff et al., 2017), and R-NEM (van Steenkiste et al., 2018a) perform unsupervised segmentation by modelling images as spatial mixture models. SCAE (Kosiorek et al., 2019) discovers geometric relationships between objects and their parts by using an affine-aware decoder. Yet, these approaches have not been shown to work on more complex images, for example visual scenes with 3D spatial structure, occlusion, perspective distortion, and multiple foreground and background components as considered in this work. Moreover, none of them demonstrate the ability to generate novel scenes with relational structure. ",
+        "bbox": [
+            174,
+            648,
+            825,
+            787
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "While Xu et al. (2018) present an extension of Eslami et al. (2016) to generate images, their method only works on binary images with a uniform black background and assumes that object bounding boxes do not overlap. In contrast, we train GENESIS on rendered 3D scenes from Eslami et al. (2018) and Groth et al. (2018) which feature complex backgrounds and considerable occlusion to perform both decomposition and generation. Lastly, Xu et al. (2019) use ground truth pixel-wise flow fields as a cue for segmenting objects or object parts. Similarly, GENESIS could be adapted to also leverage temporal information which is a promising avenue for future research. ",
+        "bbox": [
+            174,
+            795,
+            825,
+            892
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "MONet & IODINE While this work is most directly related to MONet (Burgess et al., 2019) and IODINE (Greff et al., 2019), it sets itself apart by introducing a generative model that captures relations between scene components with an autoregressive prior, enabling the unconditional generation of coherent, novel scenes. Moreover, MONet relies on a deterministic attention mechanism rather than utilising a proper probabilistic inference procedure. This implies that the training objective is not a valid lower bound on the marginal likelihood and that the model cannot perform density estimation without modification. Furthermore, this attention mechanism embeds a CNN in a RNN, posing an issue in terms of scalability. These two considerations do not apply to IODINE, but IODINE employs a gradient-based, iterative refinement mechanism which expensive both in terms of computation and memory, limiting its practicality and utility. Architecturally, GENESIS is more similar to MONet and does not require expensive iterative refinement as IODINE. Unlike MONet, though, the convolutional encoders and decoders in GENESIS can be run in parallel, rendering the model computationally more scalable to inputs with a larger number of scene components. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            284
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Adversarial Methods A few recent works have proposed to use an adversary for scene segmentation and generation. Chen et al. (2019) and Bielski & Favaro (2019) segment a single foreground object per image and Arandjelovic & Zisserman (2019) segment several synthetic objects superim- ´ posed on natural images. Azadi et al. (2019) combine two objects or an object and a background scene in a sensible fashion and van Steenkiste et al. (2018b) can generate scenes with a potentially arbitrary number of components. In comparison, GENESIS performs both inference and generation, does not exhibit the instabilities of adversarial training, and offers a probabilistic formulation which captures uncertainty, e.g. during scene decomposition. Furthermore, the complexity of GENESIS increases with $\\mathcal O ( K )$ , where $K$ is the number of components, as opposed to the $\\mathcal { O } ( K ^ { 2 } )$ complexity of the relational stage in van Steenkiste et al. (2018b). ",
+        "bbox": [
+            173,
+            290,
+            825,
+            430
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Inverse Graphics A range of works formulate scene understanding as an inverse graphics problem. These well-engineered methods, however, rely on scene annotations for training and lack probabilistic formulations. For example, Wu et al. (2017b) leverage a graphics renderer to decode a structured scene description which is inferred by a neural network. Romaszko et al. (2017) pursue a similar approach but instead make use of a differentiable graphics render. Wu et al. (2017a) further employ different physics engines to predict the movement of billiard balls and block towers. ",
+        "bbox": [
+            174,
+            436,
+            825,
+            521
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 GENESIS: GENERATIVE SCENE INFERENCE AND SAMPLING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            541,
+            700,
+            558
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first describe the generative model of GENESIS and a simplified variant called GENESIS-S. This is followed by the associated inference procedures and two possible learning objectives. GENESIS is illustrated in Figure 1 and Figure 2 shows the graphical model in comparison to alternative methods. An illustration of GENESIS-S is included Appendix B.1, Figure 5. ",
+        "bbox": [
+            174,
+            573,
+            825,
+            628
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Generative model Let $\\mathbf { x } \\in \\mathbb { R } ^ { H \\times W \\times C }$ be an image. We formulate the problem of image generation as a spatial Gaussian mixture model (GMM). That is, every Gaussian component $k = 1 , \\ldots , K$ represents an image-sized scene component $\\mathbf { x } _ { k } \\in \\mathbb { R } ^ { H \\times W \\times C }$ . $K \\in \\mathbb { N } _ { + }$ is the maximum number of scene components. The corresponding mixing probabilities $\\pi _ { k } \\in [ \\dot { 0 } , 1 ] ^ { H \\times W }$ indicate whether the component is present at a location in the image. The mixing probabilities are normalised across scene components, i.e. $\\begin{array} { r } { \\forall _ { i , j } \\sum _ { k } \\pi _ { i , j , k } = 1 } \\end{array}$ , and can be regarded as spatial attention masks. Since there are strong spatial dependencies between components, we formulate an autoregressive prior distribution over mask variables $\\mathbf { z } _ { k } ^ { m } \\in \\mathbb { R } ^ { D _ { m } }$ which encode the mixing probabilities $\\pi _ { k }$ , as ",
+        "bbox": [
+            173,
+            642,
+            825,
+            757
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/06bca52048225d6ef60f2255af1022b634ddd558d27b4e8501c7c6ac02a8941d.jpg",
+        "text": "$$\np _ { \\theta } ( \\mathbf { z } _ { 1 : K } ^ { m } ) = \\prod _ { k = 1 } ^ { K } p _ { \\theta } \\big ( \\mathbf { z } _ { k } ^ { m } \\mid \\mathbf { z } _ { 1 : k - 1 } ^ { m } \\big ) = \\prod _ { k = 1 } ^ { K } p _ { \\theta } ( \\mathbf { z } _ { k } ^ { m } \\mid \\mathbf { u } _ { k } ) \\vert _ { \\mathbf { u } _ { k } = \\mathrm { R } _ { \\theta } ( \\mathbf { z } _ { k - 1 } ^ { m } , \\mathbf { u } _ { k - 1 } ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            259,
+            763,
+            736,
+            808
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The dependence on previous latents $\\mathbf { z } _ { 1 : k - 1 } ^ { m }$ is implemented via an RNN $\\mathrm { R } _ { \\theta }$ with hidden state $\\mathbf { u } _ { k }$ ",
+        "bbox": [
+            173,
+            814,
+            802,
+            830
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Next, we assume that the scene components $\\mathbf { x } _ { k }$ are conditionally independent given their spatial allocation in the scene. The corresponding conditional distribution over component variables $\\mathbf { z } _ { k } ^ { c } \\in \\mathbb { R } ^ { D _ { c } }$ which encode the scene components $\\mathbf { x } _ { k }$ factorises as follows, ",
+        "bbox": [
+            174,
+            835,
+            823,
+            877
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0d686850094cdc7f7622ac482f69b7d7701ecc4a80c13b487957d7cc55559de3.jpg",
+        "text": "$$\np _ { \\boldsymbol { \\theta } } ( \\mathbf { z } _ { 1 : K } ^ { c } \\mid \\mathbf { z } _ { 1 : K } ^ { m } ) = \\prod _ { k = 1 } ^ { K } p _ { \\boldsymbol { \\theta } } ( \\mathbf { z } _ { k } ^ { c } \\mid \\mathbf { z } _ { k } ^ { m } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            885,
+            620,
+            928
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/7b549da9427012cef5abadef61029f537b67a57f5aec466fc26eef046d7742f4.jpg",
+        "image_caption": [
+            "Figure 1: GENESIS illustration. Given an image $\\mathbf { x }$ , an encoder and an RNN compute the mask latents $\\mathbf { z } _ { k } ^ { m }$ . These are decoded to obtain the mixing probabilities $\\pi _ { k }$ . The image and individual masks are concatenated to infer the component latents $\\mathbf { z } _ { k } ^ { c }$ from which the scene components $\\mathbf { x } _ { k }$ are decoded. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            98,
+            825,
+            267
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Now, the image likelihood is given by a mixture model, ",
+        "bbox": [
+            173,
+            345,
+            539,
+            361
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/215b80f400441c820176d2c59ac7036d7eedccf233e970bb71c9699db3bb50f0.jpg",
+        "text": "$$\np ( \\mathbf { x } \\mid \\mathbf { z } _ { 1 : K } ^ { m } , \\mathbf { z } _ { 1 : K } ^ { c } ) = \\sum _ { k = 1 } ^ { K } \\pi _ { k } p _ { \\theta } ( \\mathbf { x } _ { k } \\mid \\mathbf { z } _ { k } ^ { c } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            367,
+            632,
+            411
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where the mixing probabilities $\\pi _ { k } = \\pi _ { \\theta } ( \\mathbf { z } _ { 1 : k } ^ { m } )$ are created via a stick-breaking process (SBP) adapted from Burgess et al. (2019) as follows, slightly overloading the $\\pi$ notation, ",
+        "bbox": [
+            176,
+            417,
+            825,
+            448
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6757676c8e550d314a219e8ce641ce45c404bb6c64d0e0e2434b0f7d83b916b4.jpg",
+        "text": "$$\n\\pi _ { 1 } = \\pi _ { \\theta } ( { \\bf z } _ { 1 } ^ { m } ) , \\qquad \\pi _ { k } = \\left( 1 - \\sum _ { j = 1 } ^ { k - 1 } \\pi _ { j } \\right) \\pi _ { \\theta } ( { \\bf z } _ { k } ^ { m } ) , \\qquad \\pi _ { K } = \\left( 1 - \\sum _ { j = 1 } ^ { K - 1 } \\pi _ { j } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            235,
+            453,
+            763,
+            503
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that this step is not necessary for our model and instead one could use a softmax to normalise masks as in Greff et al. (2019). ",
+        "bbox": [
+            173,
+            510,
+            825,
+            539
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Finally, omitting subscripts, the full generative model can be written as ",
+        "bbox": [
+            173,
+            545,
+            640,
+            560
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/109c062478934f1a43c988ae82759eb5f12583b8756110f6e8fcd66ea677cfab.jpg",
+        "text": "$$\np _ { \\theta } ( \\mathbf { x } ) = \\iint p _ { \\theta } ( \\mathbf { x } \\mid \\mathbf { z } ^ { c } , \\mathbf { z } ^ { m } ) p _ { \\theta } ( \\mathbf { z } ^ { c } \\mid \\mathbf { z } ^ { m } ) p _ { \\theta } ( \\mathbf { z } ^ { m } ) \\mathrm { d } \\mathbf { z } ^ { m } \\mathrm { d } \\mathbf { z } ^ { c } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            565,
+            689,
+            599
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where we assume that all conditional distributions are Gaussian. The Gaussian components of the image likelihood have a fixed scalar standard deviation $\\sigma _ { x } ^ { 2 }$ . We refer to this model as GENESIS. To investigate whether separate latents for masks and component appearances are necessary for decomposition, we consider a simplified model, GENESIS-S, with a single latent variable per component, ",
+        "bbox": [
+            174,
+            604,
+            825,
+            661
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/61313eab70a62c15faf7d9c3ebf1dffd373f464b11619ca1ee82be4f8adbfbc1.jpg",
+        "text": "$$\np _ { \\theta } ( \\mathbf { z } _ { 1 : K } ) = \\prod _ { k = 1 } ^ { K } p _ { \\theta } ( \\mathbf { z } _ { k } \\mid \\mathbf { z } _ { 1 : k - 1 } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            667,
+            607,
+            712
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this case, $\\mathbf { z } _ { k }$ takes the role of $\\mathbf { z } _ { k } ^ { c }$ in Equation (3) and of $\\mathbf { z } _ { k } ^ { m }$ in Equation (4), while Equation (2) is no longer necessary. ",
+        "bbox": [
+            173,
+            718,
+            825,
+            747
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Approximate posterior We amortise inference by using an approximate posterior distribution with parameters $\\phi$ and a structure similar to the generative model. The full approximate posterior reads as follows, ",
+        "bbox": [
+            173,
+            761,
+            825,
+            804
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6a4c66e7d270b69a484402e9c3faaa9f87d54830ae41868de6962fbe762afbff.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\displaystyle q _ { \\phi } ( \\mathbf { z } _ { 1 : K } ^ { c } , \\mathbf { z } _ { 1 : K } ^ { m } \\mid \\mathbf { x } ) = q _ { \\phi } ( \\mathbf { z } _ { 1 : K } ^ { m } \\mid \\mathbf { x } ) q _ { \\phi } ( \\mathbf { z } _ { 1 : K } ^ { c } \\mid \\mathbf { x } , \\mathbf { z } _ { 1 : K } ^ { m } ) , \\quad \\mathrm { w h e r e } } \\\\ & { \\displaystyle q _ { \\phi } ( \\mathbf { z } _ { 1 : K } ^ { m } \\mid \\mathbf { x } ) = \\prod _ { k = 1 } ^ { K } q _ { \\phi } \\big ( \\mathbf { z } _ { k } ^ { m } \\mid \\mathbf { x } , \\mathbf { z } _ { 1 : k - 1 } ^ { m } \\big ) , \\quad \\mathrm { a n d } \\quad q _ { \\phi } ( \\mathbf { z } _ { 1 : K } ^ { c } \\mid \\mathbf { x } , \\mathbf { z } _ { 1 : K } ^ { m } ) = \\prod _ { k = 1 } ^ { K } q _ { \\phi } ( \\mathbf { z } _ { k } ^ { c } \\mid \\mathbf { x } , \\mathbf { z } _ { 1 : k } ^ { m } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            187,
+            809,
+            790,
+            873
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "with the dependence on the prior, but we have n $\\mathbf { z } _ { 1 : k - 1 } ^ { m }$ realised by an RNN stigated this option. $\\mathrm { R } _ { \\phi }$ . The RNN could, in principle, be shared withll conditional distributions are Gaussian. For GENESIS-S, the approximate posterior takes the form $\\begin{array} { r } { q _ { \\phi } ( \\mathbf { z } _ { 1 : K } \\mid \\mathbf { x } ) = \\prod _ { k = 1 } ^ { K } q _ { \\phi } ( \\mathbf { z } _ { k } \\mid \\mathbf { x } , \\mathbf { z } _ { 1 : k - 1 } ) } \\end{array}$ . ",
+        "bbox": [
+            176,
+            878,
+            823,
+            926
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/707b6d2abdfe8f023bd2c778710cf715a0d7f1a4f5324348d465dac32ae78e8d.jpg",
+        "image_caption": [
+            "Figure 2: Graphical model of GENESIS compared to related methods. $N$ denotes the number of refinement iterations in IODINE. Unlike the other methods, both GENESIS variants explicitly model dependencies between scene components. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            225,
+            97,
+            771,
+            244
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Learning GENESIS can be trained by maximising the evidence lower bound (ELBO) on the logmarginal likelihood $\\log p _ { \\theta } ( \\mathbf { x } )$ , given by ",
+        "bbox": [
+            174,
+            320,
+            821,
+            349
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1ae0c768254feca79468f7cb07e3a78054716b9d7bed07ac9a7463d0aa3ae3a2.jpg",
+        "text": "$$\n{ \\begin{array} { r l } & { { \\mathcal { L } } _ { \\mathrm { E L B O } } ( \\mathbf { x } ) = \\mathbb { E } _ { q _ { \\phi } ( \\mathbf { z } ^ { c } , \\mathbf { z } ^ { m } | \\mathbf { x } ) } \\left[ \\log \\frac { p _ { \\theta } ( \\mathbf { x } \\mid \\mathbf { z } ^ { c } , \\mathbf { z } ^ { m } ) p _ { \\theta } ( \\mathbf { z } ^ { c } \\mid \\mathbf { z } ^ { m } ) p _ { \\theta } ( \\mathbf { z } ^ { m } ) } { q _ { \\phi } ( \\mathbf { z } ^ { c } \\mid \\mathbf { z } ^ { m } , \\mathbf { x } ) q _ { \\phi } ( \\mathbf { z } ^ { m } \\mid \\mathbf { x } ) } \\right] } \\\\ & { \\qquad = \\mathbb { E } _ { q _ { \\phi } ( \\mathbf { z } ^ { c } , \\mathbf { z } ^ { m } | \\mathbf { x } ) } [ \\log p _ { \\theta } ( \\mathbf { x } \\mid \\mathbf { z } ^ { c } , \\mathbf { z } ^ { m } ) ] - \\operatorname { K L } \\left( q _ { \\phi } ( \\mathbf { z } ^ { c } , \\mathbf { z } ^ { m } \\mid \\mathbf { x } ) \\mid \\mid p _ { \\theta } ( \\mathbf { z } ^ { c } , \\mathbf { z } ^ { m } ) \\right) . } \\end{array} }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            225,
+            351,
+            769,
+            407
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "However, this often leads to a strong emphasis on the likelihood term, while allowing the marginal approximate posterior $q _ { \\phi } ( \\mathbf { z } ) = \\mathbb { E } _ { p _ { \\mathrm { d a t a } } ( \\mathbf { x } ) } [ q _ { \\phi } ( \\mathbf { z } \\mid \\mathbf { x } ) ]$ to drift away from the prior distribution, hence increasing the KL-divergence. This also decreases the quality of samples drawn from the model. To prevent this behaviour, we use the Generalised ELBO with Constrained Optimisation (GECO) objective from Rezende $\\&$ Viola (2018) instead, which changes the learning problem to minimising the KL-divergence subject to a reconstruction constraint. Let $C \\in \\mathbb { R }$ be the minimum allowed reconstruction log-likelihood, GECO then uses Lagrange multipliers to solve the following problem, ",
+        "bbox": [
+            173,
+            406,
+            826,
+            503
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/335358a122d01e772d0349c318e34c5541b31d6ed919e6890f1f30f8f5795c6a.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\theta ^ { \\star } , \\phi ^ { \\star } = \\arg \\underset { \\theta , \\phi } { \\operatorname* { m i n } } \\mathrm { K L } \\left( q _ { \\phi } ( \\mathbf { z } ^ { c } , \\mathbf { z } ^ { m } \\mid \\mathbf { x } ) \\mid \\mid p _ { \\theta } ( \\mathbf { z } ^ { c } , \\mathbf { z } ^ { m } ) \\right) } \\\\ & { \\quad \\quad \\quad \\mathrm { s u c h t h a t } \\quad \\mathbb { E } _ { q _ { \\phi } ( \\mathbf { z } ^ { c } , \\mathbf { z } ^ { m } \\mid \\mathbf { x } ) } [ \\log p _ { \\theta } ( \\mathbf { x } \\mid \\mathbf { z } ^ { c } , \\mathbf { z } ^ { m } ) ] \\ge C . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            505,
+            686,
+            551
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            565,
+            326,
+            580
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present qualitative and quantitative results on coloured Multi-dSprites (Burgess et al., 2019), the “rooms-ring-camera” dataset from $G Q N$ (Eslami et al., 2018) and the ShapeStacks dataset (Groth et al., 2018). We use an image resolution of 64-by-64 for all experiments. The number of components is set to $K = 5$ , $K = 7$ , and $K = 9$ for Multi-dSprites, GQN, and ShapeStacks, respectively. More details about the datasets are provided in Appendix A. Implementation and training details of all models are described in Appendix B. ",
+        "bbox": [
+            173,
+            595,
+            825,
+            680
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 COMPONENT-WISE SCENE GENERATION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            695,
+            496,
+            710
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Unlike previous works, GENESIS has an autoregressive prior to capture intricate dependencies between scene components. Modelling these relationships is necessary to generate coherent scenes. For example, different parts of the background need to fit together; we do not want to create components such as the sky several times; and several physical objects cannot be in the same location. GENESIS is able to generate novel scenes by sequentially sampling scene components from the prior and conditioning each new component on those that have been generated during previous steps. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            805
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "After training GENESIS and MONet on the GQN dataset, Figure 3 shows the component-bycomponent generation process of novel scenes, corresponding to drawing samples from the respective prior distributions. More examples of generated scenes are shown in Figure 6, Appendix D. With GENESIS, either an object in the foreground or a part of the background is generated at every step and these components fit together to make up a semantically consistent scene that looks similar to the training data. MONet, though, generates random artefacts at every step that do not form a sensible scene. These results are striking but not surprising: MONet was not designed for scene generation. The need for such a model is why we developed GENESIS. ",
+        "bbox": [
+            174,
+            811,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/dd3b4f97277bcb2cd8347c9647b19cef2e8ea4f91fdf0a745718bfa04ed79560.jpg",
+        "image_caption": [
+            "Figure 3: Component-by-component scene generation with GENESIS and MONet after training on the GQN dataset. The first pane shows the final scene and the subsequent panes show the components generated at each step. GENESIS first generates the sky and the floor, followed by individual objects, and finally distinct parts of the wall in the background to compose a coherent scene. MONet, in contrast, only generates incomplete components that do not fit together. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            98,
+            823,
+            662
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Notably, GENESIS pursues a consistent strategy for scene generation: Step one generates the floor and the sky, defining the layout of the scene. Steps two to four generate individual foreground objects. Some of these slots remain empty if less than three objects are present in the scene. The final three steps generate the walls in the background. We conjecture that this strategy evolves during training as the floor and sky constitute large and easy to model surfaces that have a strong impact on the reconstruction loss. Finally, we observe that some slots contain artefacts of the sky at the top of the wall boundaries. We conjecture this is due to the fact that the mask decoder does not have skip connections as typically used in segmentation networks, making it difficult for the model to predict sharp segmentation boundaries. Scenes generated by GENESIS-S are shown in Figure 8 and Figure 9, Appendix D. While GENESIS-S does separate the foreground objects from the background, it generates them in one step and the individual background components are not very interpretable. ",
+        "bbox": [
+            173,
+            757,
+            825,
+            910
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 INFERENCE OF SCENE COMPONENTS",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            470,
+            117
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Like MONet and IODINE, which were designed for unsupervised scene decomposition, GENESIS is also able to segment scenes into meaningful components. Figure 4 compares the decomposition of two images from the GQN dataset with GENESIS and MONet. Both models follow a similar decomposition strategy, but MONet fails to disambiguate one foreground object in the first example and does not reconstruct the background in as much detail in the second example. In Appendix E, Figure 10 illustrates the ability of both methods to disambiguate objects of the same colour and Figure 11 shows scene decomposition with GENESIS-S. ",
+        "bbox": [
+            173,
+            128,
+            825,
+            227
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Following Greff et al. (2019), we quantify segmentation performance with the Adjusted Rand Index (ARI) of pixels overlapping with ground truth foreground objects. We computed the ARI on 300 random images from the ShapeStacks test set for five models trained with different random seeds. GENESIS achieves an ARI of $0 . 7 3 \\pm 0 . 0 3$ which is better than $0 . 6 3 \\pm 0 . 0 7$ for MONet. This metric, however, does not penalise objects being over-segmented, which can give a misleading impression with regards to segmentation quality. This is illustrated in Figure 13, Appendix E. ",
+        "bbox": [
+            174,
+            234,
+            825,
+            318
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Inspired by Arbelaez et al. (2010), we thus propose to use the segmentation covering (SC) of the ground truth foreground objects by the predicted masks. This involves taking a weighted mean over mask pairs, putting a potentially undesirable emphasis on larger objects. We therefore also consider taking an unweighted mean $\\mathrm { ( m S C ) }$ . For the same 300 images from the ShapeStacks test set and five different random seeds, GENESIS (SC: $0 . 6 4 \\pm 0 . 0 8$ , mSC: $0 . 6 0 \\pm 0 . 0 9 )$ again outperforms MONet (SC: $0 . 5 2 \\pm 0 . 0 9$ , mSC: $0 . 4 9 \\pm 0 . 0 9 )$ . More details are provided in Appendix C. ",
+        "bbox": [
+            173,
+            324,
+            825,
+            409
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/514d1e5385be20062948dc181b2816c9bec48e858e8110fb06fb558d6d719d9b.jpg",
+        "image_caption": [
+            "Figure 4: Step-by-step decomposition of the same scene from GQN with GENESIS and MONet. Unlike MONet, GENESIS clearly differentiates individual objects in the first example. In the second example, GENESIS captures the fine-grained pattern of the wall in the background better than MONet. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            424,
+            823,
+            651
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 EVALUATION OF UNSUPERVISED REPRESENTATION UTILITY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            731,
+            632,
+            746
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Using a subset of the available labelled training images from ShapeStacks, we train a set of classifiers on the representations learned by GENESIS and several baselines to evaluate how well these representations capture the ground truth scene state. In particular, we consider three tasks: (1) Is a tower stable or not? (2) What is the tower’s height in terms of the number of blocks? (3) What is the camera viewpoint (out of 16 possibilities)? Tower stability is a particularly interesting property as it depends on in fine-grained object information and the relative positioning of objects. We selected the third task as learning scene representations from different views has previously been prominently explored in Eslami et al. (2018). We compare GENESIS and GENESIS-S against three baselines: MONet, a VAE with a spatial broadcast decoder (BD-VAE) and a VAE with a deconvolutional decoder (DC-VAE). The results are summarised in Table 1. The architectural details of the baselines are described in Appendix B.2 and Appendix B.3. The implementation details of the classifiers are provided in Appendix B.5. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Both GENESIS and GENESIS-S perform better than than the baselines at predicting tower stability and their accuracies on predicting the height of the towers is only outperformed by MONet. We conjecture that MONet benefits here by its deterministic segmentation network. Overall, this corroborates the intuition that object-centric representations are indeed beneficial for these tasks which focus on the foreground objects. We observe that the BD-VAE does better than the DC-VAE on all three tasks, reflecting the motivation behind its design which is aimed at better disentangling the underlying factors of variation in the data (Watters et al., 2019b). All models achieve a high accuracy at predicting the camera view. Finally, we note that none of models reach the stability prediction accuracies reported in Groth et al. (2018) which were obtained with an Inception-v4 classifier (Szegedy et al., 2017). This is not surprising considering that only a subset the training images is used for training the classifiers without data augmentation and at a reduced resolution. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            256
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/1724d65de17d8e73e8a71decad1cb4cd67020592344971d6778941c4961299bf.jpg",
+        "table_caption": [
+            "Table 1: Classification accuracy in $\\%$ on the test sets of the ShapeStacks tasks. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Task</td><td>GENESIS</td><td>GENESIS-S</td><td>MONet</td><td>BD-VAE</td><td>DC-VAE</td><td>Random</td></tr><tr><td>Stability</td><td>64.0</td><td>63.2</td><td>59.6</td><td>60.1</td><td>59.0</td><td>50.0</td></tr><tr><td>Height</td><td>80.3</td><td>80.8</td><td>88.4</td><td>78.6</td><td>67.5</td><td>22.8</td></tr><tr><td>View</td><td>99.3</td><td>99.7</td><td>99.5</td><td>99.7</td><td>99.1</td><td>6.25</td></tr></table>",
+        "bbox": [
+            222,
+            295,
+            774,
+            367
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 QUANTIFYING SAMPLE QUALITY",
+        "text_level": 1,
+        "bbox": [
+            176,
+            392,
+            446,
+            406
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In order to quantify the quality of generated scenes, Table 2 summarises the Fréchet Inception Distances (FIDs) (Heusel et al., 2017) between 10,000 images generated by GENESIS as well several baselines and 10,000 images from the Multi-dSprites and the GQN test sets, respectively. The two GENESIS variants achieve the best FID on both datasets. While GENESIS-S performs better than GENESIS on GQN, Figure 8 and Figure 9 in Appendix D show that individual scene components are less interpretable and that intricate background patterns are generated at the expense of sensible foreground objects. It is not surprising that the FIDs for MONet are relatively large given that it was not designed for generating scenes. Interestingly, the DC-VAE achieves a smaller FID on GQN than the BD-VAE. This is surprising given that the BD-VAE representations are more useful for the ShapeStacks classification tasks. Given that the GQN dataset and ShapeStacks are somewhat similar in structure and appearance, this indicates that while FID correlates with perceptual similarity, it does not necessarily correlate with the general utility of the learned representations for downstream tasks. We include scenes sampled from the BD-VAE and the DC-VAE in Figure 7, Appendix D, where we observe that the DC-VAE models the background fairly well while foreground objects are blurry. ",
+        "bbox": [
+            173,
+            417,
+            825,
+            613
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/5acd5534c7be6b94749f7a02fc8f8c92ff7f7253357332849665187e64055f01.jpg",
+        "table_caption": [
+            "Table 2: Fréchet Inception Distances for GENESIS and baselines on GQN. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>GENESIS</td><td>GENESIS-S</td><td>MONet</td><td>BD-VAE</td><td>DC-VAE</td></tr><tr><td>Multi-dSprites</td><td>24.9</td><td>28.2</td><td>92.7</td><td>89.8</td><td>100.5</td></tr><tr><td>GQN</td><td>80.5</td><td>70.2</td><td>176.4</td><td>145.5</td><td>82.5</td></tr></table>",
+        "bbox": [
+            236,
+            651,
+            758,
+            709
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            736,
+            328,
+            752
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose a novel object-centric latent variable model of scenes called GENESIS. We show that GENESIS is, to the best of our knowledge, the first unsupervised model to both decompose rendered 3D scenes into semantically meaningful constituent parts, while at the same time being able to generate coherent scenes in a component-wise fashion. This is achieved by capturing relationships between scene components with an autoregressive prior that is learned alongside a computationally efficient sequential inference network, setting GENESIS apart from prior art. Regarding future work, an interesting challenge is to scale GENESIS to more complex datasets and to employ the model in robotics or reinforcement learning applications. To this end, it will be necessary to improve reconstruction and sample quality, reduce computational cost, and to scale the model to higher resolution images. Another potentially promising research direction is to adapt the formulation to only model parts of the scene that are relevant for a certain task. ",
+        "bbox": [
+            173,
+            767,
+            825,
+            921
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            104,
+            326,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This research was supported by an EPSRC Programme Grant (EP/M019918/1), an EPSRC DTA studentship, and a Google studentship. The authors would like to acknowledge the use of the University of Oxford Advanced Research Computing (ARC) facility in carrying out this work, http://dx.doi.org/10.5281/zenodo.22558, and the use of Hartree Centre resources. The authors would like to thank Yizhe Wu for his help with re-implementing MONet, Oliver Groth for his support with the GQN and ShapeStacks datasets, and Rob Weston for proof reading the paper. ",
+        "bbox": [
+            174,
+            127,
+            825,
+            212
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            232,
+            285,
+            247
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Relja Arandjelovic and Andrew Zisserman. Object Discovery with a Copy-Pasting GAN. ´ arXiv preprint arXiv:1905.11369, 2019. ",
+        "bbox": [
+            174,
+            255,
+            823,
+            284
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pablo Arbelaez, Michael Maire, Charless Fowlkes, and Jitendra Malik. Contour Detection and Hierarchical Image Segmentation. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2010. ",
+        "bbox": [
+            176,
+            291,
+            821,
+            334
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Samaneh Azadi, Deepak Pathak, Sayna Ebrahimi, and Trevor Darrell. Compositional GAN: Learning Image-Conditional Binary Composition. arXiv preprint arXiv:1807.07560, 2019. ",
+        "bbox": [
+            173,
+            343,
+            823,
+            372
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Rianne van den Berg, Leonard Hasenclever, Jakub M Tomczak, and Max Welling. Sylvester Normalizing Flows for Variational Inference. Conference on Uncertainty in Artificial Intelligence, 2018. ",
+        "bbox": [
+            174,
+            380,
+            821,
+            422
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Adam Bielski and Paolo Favaro. Emergence of Object Segmentation in Perturbed Generative Models. arXiv preprint arXiv:1905.12663, 2019. ",
+        "bbox": [
+            171,
+            430,
+            821,
+            460
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Andrew Brock, Jeff Donahue, and Karen Simonyan. Large Scale GAN Training for High Fidelity Natural Image Synthesis. arXiv preprint arXiv:1809.11096, 2018. ",
+        "bbox": [
+            173,
+            468,
+            823,
+            497
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Christopher P Burgess, Loic Matthey, Nicholas Watters, Rishabh Kabra, Irina Higgins, Matt Botvinick, and Alexander Lerchner. MONet: Unsupervised Scene Decomposition and Representation. arXiv preprint arXiv:1901.11390, 2019. ",
+        "bbox": [
+            176,
+            505,
+            821,
+            549
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mickaël Chen, Thierry Artières, and Ludovic Denoyer. Unsupervised Object Segmentation by Redrawing. arXiv preprint arXiv:1905.13539, 2019. ",
+        "bbox": [
+            171,
+            556,
+            823,
+            585
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Djork-Arné Clevert, Thomas Unterthiner, and Sepp Hochreiter. Fast and Accurate Deep Network Learning by Exponential Linear Units (ELUs). International Conference on Learning Representations, 2016. ",
+        "bbox": [
+            173,
+            593,
+            823,
+            636
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pierre Comon. Independent Component Analysis. In J-L.Lacoume (ed.), Higher-Order Statistics, pp. 29–38. Elsevier, 1992. ",
+        "bbox": [
+            173,
+            643,
+            821,
+            672
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Eric Crawford and Joelle Pineau. Spatially Invariant Unsupervised Object Detection with Convolutional Neural Networks. AAAI Conference on Artificial Intelligence, 2019. ",
+        "bbox": [
+            174,
+            681,
+            820,
+            710
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yann N Dauphin, Angela Fan, Michael Auli, and David Grangier. Language Modeling with Gated Convolutional Networks. International Conference on Machine Learning, 2017. ",
+        "bbox": [
+            174,
+            718,
+            820,
+            748
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "SM Ali Eslami, Nicolas Heess, Theophane Weber, Yuval Tassa, David Szepesvari, Geoffrey E Hinton, et al. Attend, Infer, Repeat: Fast Scene Understanding with Generative Models. Neural Information Processing Systems, 2016. ",
+        "bbox": [
+            176,
+            756,
+            823,
+            799
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "SM Ali Eslami, Danilo Jimenez Rezende, Frederic Besse, Fabio Viola, Ari S Morcos, Marta Garnelo, Avraham Ruderman, Andrei A Rusu, Ivo Danihelka, Karol Gregor, et al. Neural Scene Representation and Rendering. Science, 2018. ",
+        "bbox": [
+            173,
+            806,
+            823,
+            849
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Karl Friston. A Theory of Cortical Responses. Philosophical Transactions of the Royal Society B: Biological Sciences, 360(1456):815–836, 2005. ",
+        "bbox": [
+            174,
+            858,
+            820,
+            887
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xavier Glorot, Antoine Bordes, and Yoshua Bengio. Deep Sparse Rectifier Neural Networks. International Conference on Artificial Intelligence and Statistics, 2011. ",
+        "bbox": [
+            173,
+            895,
+            818,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Klaus Greff, Antti Rasmus, Mathias Berglund, Tele Hao, Harri Valpola, and Jürgen Schmidhuber. Tagger: Deep Unsupervised Perceptual Grouping. Neural Information Processing Systems, 2016. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Klaus Greff, Sjoerd van Steenkiste, and Jürgen Schmidhuber. Neural Expectation Maximization. Neural Information Processing Systems, 2017. ",
+        "bbox": [
+            173,
+            142,
+            821,
+            171
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Klaus Greff, Raphaël Lopez Kaufmann, Rishab Kabra, Nick Watters, Chris Burgess, Daniel Zoran, Loic Matthey, Matthew Botvinick, and Alexander Lerchner. Multi-Object Representation Learning with Iterative Variational Inference. International Conference on Machine Learning, 2019. ",
+        "bbox": [
+            174,
+            183,
+            825,
+            238
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karol Gregor, Danilo Jimenez Rezende, Frederic Besse, Yan Wu, Hamza Merzic, and Aaron van den Oord. Shaping Belief States with Generative Environment Models for RL. arXiv preprint arXiv:1906.09237, 2019. ",
+        "bbox": [
+            174,
+            250,
+            826,
+            291
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kalanit Grill-Spector and Rafael Malach. The Human Visual Cortex. Annual Review of Neuroscience, 27(1):649–677, 2004. ",
+        "bbox": [
+            171,
+            303,
+            821,
+            332
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Oliver Groth, Fabian B Fuchs, Ingmar Posner, and Andrea Vedaldi. ShapeStacks: Learning VisionBased Physical Intuition for Generalised Object Stacking. European Conference on Computer Vision, 2018. ",
+        "bbox": [
+            176,
+            342,
+            823,
+            385
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Ha and Jürgen Schmidhuber. World Models. Neural Information Processing Systems, 2018. ",
+        "bbox": [
+            171,
+            395,
+            820,
+            411
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. GANs Trained by a Two Time-Scale Update Rule Converge to a Local Nash Equilibrium. Neural Information Processing Systems, 2017. ",
+        "bbox": [
+            174,
+            420,
+            825,
+            463
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jürgen Schmidhuber. Long Short-Term Memory. Neural Computation, 1997. ",
+        "bbox": [
+            173,
+            474,
+            818,
+            491
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Huang and Kevin Murphy. Efficient Inference in Occlusion-Aware Generative models of Images. arXiv preprint arXiv:1511.06362, 2015. ",
+        "bbox": [
+            173,
+            500,
+            825,
+            530
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "D. H. Hubel and T. N. Wiesel. Receptive Fields and Functional Architecture of Monkey Striate Cortex. The Journal of Physiology, 195(1):215–243, 1968. ",
+        "bbox": [
+            173,
+            540,
+            823,
+            569
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift. International Conference on Machine Learning, 2015. ",
+        "bbox": [
+            173,
+            579,
+            823,
+            608
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael I Jordan, Zoubin Ghahramani, Tommi S Jaakkola, and Lawrence K Saul. An Introduction to Variational Methods for Graphical Models. Machine Learning, 37(2):183–233, 1999. ",
+        "bbox": [
+            171,
+            618,
+            823,
+            647
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A Method for Stochastic Optimization. International Conference on Learning Representations, 2015. ",
+        "bbox": [
+            173,
+            657,
+            823,
+            688
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Max Welling. Auto-Encoding Variational Bayes. International Conference on Learning Representations, 2014. ",
+        "bbox": [
+            173,
+            698,
+            825,
+            727
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Adam Kosiorek, Hyunjik Kim, Yee Whye Teh, and Ingmar Posner. Sequential Attend, Infer, Repeat: Generative Modelling of Moving Objects. Neural Information Processing Systems, 2018. ",
+        "bbox": [
+            173,
+            736,
+            823,
+            767
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Adam R Kosiorek, Sara Sabour, Yee Whye Teh, and Geoffrey E Hinton. Stacked Capsule Autoencoders. arXiv preprint arXiv:1906.06818, 2019. ",
+        "bbox": [
+            171,
+            776,
+            823,
+            806
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Loic Matthey, Irina Higgins, Demis Hassabis, and Alexander Lerchner. dSprites: Disentanglement Testing Sprites Dataset. https://github.com/deepmind/dsprites-dataset/, 2017. ",
+        "bbox": [
+            171,
+            815,
+            823,
+            845
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bruno A. Olshausen and David J. Field. Emergence of Simple-Cell Receptive Field Properties by Learning a Sparse Code for Natural Images. Nature, 381:607–609, 1996. ",
+        "bbox": [
+            171,
+            856,
+            823,
+            885
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Niki Parmar, Ashish Vaswani, Jakob Uszkoreit, Łukasz Kaiser, Noam Shazeer, Alexander Ku, and Dustin Tran. Image Transformer. International Conference on Machine Learning, 2018. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rajesh P. N. Rao and Dana H. Ballard. Predictive Coding in the Visual Cortex: A Functional Interpretation of Some Extra-Classical Receptive-Field Effects. Nature Neuroscience, 2(1):79– 87, 1999. ",
+        "bbox": [
+            174,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Danilo Jimenez Rezende and Fabio Viola. Taming VAEs. arXiv preprint arXiv:1810.00597, 2018. ",
+        "bbox": [
+            173,
+            155,
+            820,
+            171
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic Backpropagation and Approximate Inference in Deep Generative Models. International Conference on Machine Learning, 2014. ",
+        "bbox": [
+            176,
+            178,
+            821,
+            222
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lukasz Romaszko, Christopher KI Williams, Pol Moreno, and Pushmeet Kohli. Vision-as-InverseGraphics: Obtaining a Rich 3D Explanation of a Scene from a Single Image. In IEEE International Conference on Computer Vision, 2017. ",
+        "bbox": [
+            174,
+            229,
+            821,
+            273
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Adam Santoro, David Raposo, David G. T. Barrett, Mateusz Malinowski, Razvan Pascanu, Peter W. Battaglia, and Timothy P. Lillicrap. A Simple Neural Network Module for Relational Reasoning. Neural Information Processing Systems, 2017. ",
+        "bbox": [
+            173,
+            281,
+            825,
+            325
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Sergey Ioffe, Vincent Vanhoucke, and Alexander A Alemi. Inception-V4, Inception-Resnet and the Impact of Residual Connections on Learning. AAAI Conference on Artificial Intelligence, 2017. ",
+        "bbox": [
+            173,
+            333,
+            823,
+            376
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Naftali Tishby, Fernando C Pereira, and William Bialek. The Information Bottleneck Method. arXiv preprint arXiv:physics/0004057, 2000. ",
+        "bbox": [
+            171,
+            385,
+            825,
+            414
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sjoerd van Steenkiste, Michael Chang, Klaus Greff, and Jürgen Schmidhuber. Relational Neural Expectation Maximization: Unsupervised Discovery of Objects and their Interactions. arXiv preprint arXiv:1802.10353, 2018a. ",
+        "bbox": [
+            173,
+            421,
+            826,
+            465
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sjoerd van Steenkiste, Karol Kurach, and Sylvain Gelly. A Case for Object Compositionality in Deep Generative Models of Images. NeurIPS Workshop on Modeling the Physical World: Learning, Perception, and Control, 2018b. ",
+        "bbox": [
+            173,
+            473,
+            823,
+            517
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sjoerd van Steenkiste, Francesco Locatello, Jurgen Schmidhuber, and Olivier Bachem. Are Disentangled Representations Helpful for Abstract Visual Reasoning? arXiv preprint arXiv:1905.12506, 2019. ",
+        "bbox": [
+            173,
+            526,
+            823,
+            569
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Brian A. Wandell. Foundations of Vision. Sinauer Associates, 1995. ",
+        "bbox": [
+            171,
+            577,
+            620,
+            593
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Watters, Loic Matthey, Matko Bosnjak, Christopher P Burgess, and Alexander Lerchner. COBRA: Data-Efficient Model-Based RL through Unsupervised Object Discovery and CuriosityDriven Exploration. arXiv preprint arXiv:1905.09275, 2019a. ",
+        "bbox": [
+            176,
+            601,
+            821,
+            645
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Watters, Loic Matthey, Christopher P Burgess, and Alexander Lerchner. Spatial Broadcast Decoder: A Simple Architecture for Learning Disentangled Representations in VAEs. arXiv preprint arXiv:1901.07017, 2019b. ",
+        "bbox": [
+            176,
+            652,
+            825,
+            695
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jiajun Wu, Erika Lu, Pushmeet Kohli, Bill Freeman, and Josh Tenenbaum. Learning to See Physics via Visual De-Animation. Neural Information Processing Systems, 2017a. ",
+        "bbox": [
+            171,
+            704,
+            823,
+            734
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jiajun Wu, Joshua B Tenenbaum, and Pushmeet Kohli. Neural Scene De-rendering. IEEE Conference on Computer Vision and Pattern Recognition, pp. 699–707, 2017b. ",
+        "bbox": [
+            169,
+            742,
+            823,
+            772
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kun Xu, Chongxuan Li, Jun Zhu, and Bo Zhang. Multi-Objects Generation with Amortized Structural Regularization. Neural Information Processing Systems, 2018. ",
+        "bbox": [
+            171,
+            780,
+            823,
+            809
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhenjia Xu, Zhijian Liu, Chen Sun, Kevin Murphy, William T Freeman, Joshua B Tenenbaum, and Jiajun Wu. Unsupervised Discovery of Parts, Structure, and Dynamics. arXiv preprint arXiv:1903.05136, 2019. ",
+        "bbox": [
+            173,
+            818,
+            825,
+            861
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            297,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Multi-dSprites (Burgess et al., 2019) Images contain between one and four randomly selected “sprites” from Matthey et al. (2017), available at https://github.com/deepmind/ dsprites-dataset. For each object and the background, we randomly select one of five different, equally spread values for each of the three colour channels and generate 70,000 images. We set aside 10,000 for validation and testing each. The script for generating this data will be released with the rest of our code. ",
+        "bbox": [
+            174,
+            137,
+            825,
+            219
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "GQN (Eslami et al., 2018) The “rooms-ring-camera” dataset includes simulated 3D scenes of a square room with different floor and wall textures, containing one to three objects of various shapes and sizes. It can be downloaded from https://github.com/deepmind/gqn-datasets. ",
+        "bbox": [
+            174,
+            228,
+            823,
+            270
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "ShapeStacks (Groth et al., 2018) Images show simulated block towers of different heights (two to six blocks). Individual blocks can have different shapes, sizes, and colours. Scenes have annotations for: stability of the tower (binary), number of blocks (two to six), properties of individual blocks, locations in the tower of centre-of-mass violations and planar surface violations, wall and floor textures (five each), light presets (five), and camera view points (sixteen). More details about the dataset and download links can be found at https://shapestacks.robots.ox.ac.uk/. ",
+        "bbox": [
+            174,
+            276,
+            825,
+            361
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            386,
+            439,
+            402
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B.1 GENESIS ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            421,
+            395,
+            435
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We use the architecture from Berg et al. (2018) to encode and decode $\\mathbf { z } _ { k } ^ { m }$ with the only modification of applying batch normalisation (Ioffe & Szegedy, 2015) before the GLU non-linearities (Dauphin et al., 2017). The convolutional layers in the encoder and decoder have five layers with size-5 kernels, strides of [1, 2, 1, 2, 1], and filter sizes of [32, 32, 64, 64, 64] and [64, 32, 32, 32, 32], respectively. Fully-connected layers are used at the lowest resolution. ",
+        "bbox": [
+            174,
+            449,
+            825,
+            520
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The encoded image is passed to a long short-term memory (LSTM) cell (Hochreiter & Schmidhuber, 1997) followed by a linear layer to compute the mask latents $\\mathbf { z } _ { k } ^ { m }$ of size 64. The LSTM state size is twice the latent size. Importantly, unlike the analogous counterpart in MONet, the decoding of $\\mathbf { z } _ { k } ^ { m }$ is performed in parallel. The autoregressive prior $\\overline { { p } } _ { \\theta } \\left( \\mathbf { z } _ { k } ^ { m } \\mid \\mathbf { z } _ { 1 : k - 1 } ^ { m } \\right)$ is implemented as an LSTM with 256 units. The conditional distribution $p _ { \\theta } ( \\mathbf { z } _ { k } ^ { c } \\mid \\mathbf { z } _ { k } ^ { m } )$ is parameterised by a multilayer perceptron (MLP) with two hidden layers, 256 units per layer, and ELUs (Clevert et al., 2016). We use the same component VAE featuring a spatial broadcast decoder as MONet to encode and decode $z _ { k } ^ { c }$ , but we replace RELUs (Glorot et al., 2011) with ELUs. ",
+        "bbox": [
+            174,
+            526,
+            825,
+            640
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For GENESIS-S, as illustrated in Figure 5, the encoder of $\\mathbf { z } _ { k }$ is the same as for $\\mathbf { z } _ { k } ^ { m }$ above and the decoder from Berg et al. (2018) is again used to compute the mixing probabilities. However, GENESIS-S also has a second decoder with spatial broadcasting to obtain the scene components $\\mathbf { x } _ { k }$ from $\\mathbf { z } _ { k }$ . We found the use of two different decoders to be important for GENESIS-S in order for the model to decompose the input. ",
+        "bbox": [
+            174,
+            646,
+            825,
+            717
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/fbf7d415b33ea3ead95520bb83a52a942598dcdcea897aaa0836d75a64f0a98c.jpg",
+        "image_caption": [
+            "Figure 5: GENESIS-S overview. Given an image x, an encoder and an RNN compute latent variables $\\mathbf { z } _ { k }$ . These are decoded to directly obtain the mixing probabilities $\\pi _ { k }$ and the scene components $\\mathbf { x } _ { k }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            334,
+            733,
+            663,
+            867
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B.2 MONET BASELINES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            357,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We followed the provided architectural details described in Burgess et al. (2019). Regarding unspecified details, we employ an attention network with [32, 32, 64, 64, 64] filters in the encoder and the reverse in the decoder. Furthermore, we normalise the mask prior with a softmax function to compute the KL-divergence between mask posterior and prior distributions. ",
+        "bbox": [
+            174,
+            128,
+            825,
+            185
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B.3 VAE BASELINES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            202,
+            334,
+            215
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Both the BD-VAE and the DC-VAE have a latent dimensionality of 64 and the same encoder as in Berg et al. (2018). The DC-VAE also uses the decoder from Berg et al. (2018). The BD-VAE has the same spatial broadcast decoder with ELUs as GENESIS, but with twice the number of filters to enable a better comparison. ",
+        "bbox": [
+            174,
+            227,
+            825,
+            284
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B.4 OPTIMISATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            299,
+            321,
+            314
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The scalar standard deviation of the Gaussian image likelihood components is set to $\\sigma _ { x } = 0 . 7$ . We use GECO (Rezende & Viola, 2018) to balance the reconstruction and KL divergence terms in the loss function. The goal for the reconstruction error is set to 0.5655, multiplied by the image dimensions and number of colour channels. We deliberately choose a comparatively weak reconstruction constraint for the GECO objective to emphasise KL minimisation and sample quality. For the remainining GECO hyperparameters, the default value of $\\alpha = 0 . 9 9$ is used and the step size for updating $\\beta$ is set to $1 0 ^ { - 5 }$ . We increase the step size to $1 0 ^ { - 4 }$ when the reconstruction constraint is satisfied to accelerate optimisation as $\\beta$ tended to undershoot at the beginning of training. ",
+        "bbox": [
+            174,
+            324,
+            825,
+            438
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "All models are trained for $5 * 1 0 ^ { 5 }$ iterations with a batch size of 32 using the ADAM optimiser (Kingma & Ba, 2015) and a learning rate of $1 0 ^ { - 4 }$ . With these settings, training GENESIS takes about two days on a single GPU. However, we expect performance to improve with further training. This particularly extends to training GENESIS on ShapeStacks where $5 * 1 0 ^ { 5 }$ training iterations are not enough to achieve good sample quality. ",
+        "bbox": [
+            174,
+            443,
+            825,
+            513
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B.5 SHAPESTACKS CLASSIFIERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            529,
+            413,
+            544
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Multilayer perceptrons (MLPs) with one hidden layer, 512 units, and ELU activations are used for classification. The classifiers are trained for 100 epochs on 50,000 labelled examples with a batch size of 128 using a cross-entropy loss, the ADAM optimiser, and a learning rate of $1 0 ^ { - 4 }$ . As inputs to the classifiers, we concatenate $\\mathbf { z } _ { k } ^ { m }$ and $\\mathbf { z } _ { k } ^ { c }$ for GENESIS, $\\mathbf { z } _ { k }$ for GENESIS-S, and the component VAE latents for the two MONet variants. ",
+        "bbox": [
+            174,
+            555,
+            825,
+            626
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C SEGMENTATION COVERING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            645,
+            437,
+            661
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Following Arbelaez et al. (2010), the segmentation covering (SC) is based on the intersection over union (IOU) between pairs of segmentation masks from two sets $S$ and $S ^ { \\prime }$ . In this work, we consider $S$ to be the segmentation masks of the ground truth foreground objects and $S ^ { \\prime }$ to be the predicted segmentation masks. The covering of $S$ by $S ^ { \\prime }$ is defined as: ",
+        "bbox": [
+            174,
+            675,
+            825,
+            731
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7cd2b0186407906863dc6eb08ba306a2e5cb3e9348018ff05a2dd67c77070dd8.jpg",
+        "text": "$$\nC ( S ^ { \\prime }  S ) = \\frac { 1 } { \\sum _ { R \\in S } | R | } \\sum _ { R \\in S } | R | \\operatorname* { m a x } _ { R ^ { \\prime } \\in S ^ { \\prime } } \\operatorname { I O U } ( R , R ^ { \\prime } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            733,
+            673,
+            770
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $| R |$ denotes the number of pixels belonging to mask $R$ . Note that this formulation is slightly more general than the one in Arbelaez et al. (2010) which assumes that masks in $S$ are nonoverlapping and cover the entire image. The above takes a weighted mean over IOU values, proportional to the number of pixels of the masks being covered. To give equal importance to masks of different sizes, we also consider taking an unweighted mean (mSC): ",
+        "bbox": [
+            174,
+            771,
+            825,
+            842
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8b252e7ad2d2c82fea0e783435cc74ffcdceadfbe38edce73be183bae425f584.jpg",
+        "text": "$$\nC _ { m } ( S ^ { \\prime }  S ) = \\frac { 1 } { | S | } \\sum _ { R \\in S } \\operatorname* { m a x } _ { R ^ { \\prime } \\in S ^ { \\prime } } \\operatorname { I O U } ( R , R ^ { \\prime } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            842,
+            642,
+            881
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $| S |$ denotes the number of non-empty masks in $S$ . Importantly and unlike the ARI, both segmentation covering variations penalise the over-segmentation of ground truth objects as this decreases the IOU for a pair of masks. This is illustrated in Figure 13, Appendix E. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D COMPONENT-WISE SCENE GENERATION - GQN ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            102,
+            611,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/92e97ef3885b0aa4ebfc85243083f1644c63934a47d2f4e36bf2e6f2659eec48.jpg",
+        "image_caption": [
+            "Figure 6: Randomly selected scenes generated by GENESIS and MONet after training on the GQN dataset. Images sampled from GENESIS contain clearly distinguishable foreground objects and backgrounds. Samples from MONet, however, are mostly incoherent. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            138,
+            823,
+            502
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/99adb7fedf7331d9a2c2fcbbd5954b8b9dc75324dd40460dae3ae2468d1111b5.jpg",
+        "image_caption": [
+            "Figure 7: Randomly selected scenes generated by the BD-VAE and the DC-VAE after training on the GQN dataset; shown for comparison. The DC-VAE generates decent scene backgrounds but foreground objects are blurry. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            575,
+            823,
+            819
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/0606440d9481eab1fe70105a952b7c379b9d5076a0b58f30b52e9fe33736082f.jpg",
+        "image_caption": [
+            "Figure 8: Component-by-component scene generation with GENESIS-S after training on the GQN dataset. While GENESIS-S nominally achieves the best FID in Table 2, this appears to be due to the generation of high fidelity background patterns rather than appropriate foreground objects. Furthermore, unlike the components generated by GENESIS at every step in Figure 3, the components generated by GENESIS-S are not very interpretable. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            128,
+            823,
+            497
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/237513bd882ebf8e997b48c9184a362fec3284fa16e195dcb2aa63fc5b268350.jpg",
+        "image_caption": [
+            "Figure 9: Randomly selected scenes generated by GENESIS-S after training on the GQN dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            635,
+            823,
+            871
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "E INFERENCE OF SCENE COMPONENTS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            516,
+            118
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/09800ff9f138399ace17ccea3c16fd50580fb1ec9c407773fc40c1c044f78d07.jpg",
+        "image_caption": [
+            "Figure 10: Step-by-step decomposition of a scene from GQN with GENESIS and MONet. Two objects with the same shape and colour are successfully identified by both models. While colour and texture are useful cues for decomposition, this example shows that both models perform something more useful than merely identifying regions of similar colour. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            140,
+            823,
+            262
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/347ee4a9456a67fcae7fce39b09cad3dd231fe956997b0deaded7f32688565c7.jpg",
+        "image_caption": [
+            "Figure 11: Step-by-step decomposition of the same scenes as in Figure 4 and Figure 10 with GENESIS-S. While the foreground objects are distinguished from the background, they are explained together in the first step. Subsequent steps reconstruct the background in a haphazard fashion. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            353,
+            825,
+            529
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/7ad08c18df8b6516fcc4b65dfef8b1b7f9c2509ee09412fb4fb4243cb831efd9.jpg",
+        "image_caption": [
+            "Figure 12: A ShapeStacks tower is decomposed by GENESIS and MONet. Compared to the GQN dataset, both methods struggle to segment the foreground objects properly. GENESIS captures the purple shape and parts of the background wall in step $k = 4$ . MONet explains the green shape, the cyan shape, and parts of floor in step $k \\ = \\ 9$ . This is reflected in the foreground ARI and segmentation covering for GENESIS (ARI: 0.82, SC: 0.68, mSC: 0.58) and MONet (ARI: 0.39, SC: 0.26, mSC: 0.35); the latter being lower as the green and cyan shapes are not separated. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            116,
+            825,
+            395
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/774561359179c582699ce422039920296499d7047124e128a05ed57256226af0.jpg",
+        "image_caption": [
+            "Figure 13: In this example, GENESIS (ARI: 0.83, SC: 0.83, mSC: 0.83) segments the four foreground objects properly. MONet (ARI: 0.89, SC: 0.47, mSC: 0.50), however, merges foreground objects and background again in steps $k = 2$ and $k = 9$ . Despite the inferior decomposition, the ARI for MONet is higher than for GENESIS. This is possible as the ARI does not penalise the over-segmentation of the foreground objects, highlighting its limitations for evaluating unsupervised instance segmentation. The segmentation covering, however, reflects the quality of the segmentatioin masks properly. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            531,
+            825,
+            809
+        ],
+        "page_idx": 16
+    }
+]

parse/train/H1-nGgWC-/H1-nGgWC-.md

@@ -0,0 +1,487 @@
+# GAUSSIAN PROCESS BEHAVIOUR IN WIDE DEEP NEURAL NETWORKS
+
+Alexander G. de G. Matthews University of Cambridge am554@cam.ac.uk
+
+Jiri Hron University of Cambridge jh2084@cam.ac.uk
+
+Mark Rowland University of Cambridge mr504@cam.ac.uk
+
+Richard E. Turner University of Cambridge ret26@cam.ac.uk
+
+Zoubin Ghahramani University of Cambridge, Uber AI Labs zoubin@eng.cam.ac.uk
+
+# ABSTRACT
+
+Whilst deep neural networks have shown great empirical success, there is still much work to be done to understand their theoretical properties. In this paper, we study the relationship between Gaussian processes with a recursive kernel definition and random wide fully connected feedforward networks with more than one hidden layer. We exhibit limiting procedures under which finite deep networks will converge in distribution to the corresponding Gaussian process. To evaluate convergence rates empirically, we use maximum mean discrepancy. We then exhibit situations where existing Bayesian deep networks are close to Gaussian processes in terms of the key quantities of interest. Any Gaussian process has a flat representation. Since this behaviour may be undesirable in certain situations we discuss ways in which it might be prevented. 1
+
+# 1 INTRODUCTION
+
+Deep feedforward neural networks have emerged as an essential component of modern machine learning. As such there has been significant research effort in trying to understand the theoretical properties of such models. One important branch of such research is the study of random networks. By assuming a probability distribution on the network parameters, a distribution is induced on the input to output function that such networks encode. This has proved important in the study of initialisation and learning dynamics (Schoenholz et al., 2017) and expressivity (Poole et al., 2016). It is, of course, essential in the study of Bayesian priors on networks (Neal, 1996). The Bayesian approach makes little sense if prior assumptions are not understood, and distributional knowledge can be essential in finding good posterior approximations.
+
+Since we typically want our networks to have high modelling capacity, it is natural to consider limit distributions of networks as they become large. Whilst distributions on deep networks are generally challenging to work with exactly, the limiting behaviour can lead to more insight. Further, as we shall see, networks used in the literature may be very close to this behaviour.
+
+The seminal work in this area is that of Neal (1996), which showed that under certain conditions random neural networks with one hidden layer converge to a Gaussian process. The question of the type of convergence is non-trivial and part of our discussion. Historically this result was a significant one because it provided a connection between flexible Bayesian neural networks and Gaussian processes (Williams, 1998; Rasmussen & Williams, 2006)
+
+# 1.1 OUR CONTRIBUTIONS
+
+We extend the theoretical understanding of random fully connected networks and their relationship to Gaussian processes. In particular, we prove a rigorous result (Theorem 1) on the convergence of certain finite networks with more than one hidden layer to Gaussian processes.
+
+Further, we empirically study the distance between finite networks and their Gaussian process analogues by using maximum mean discrepancy (Gretton et al., 2012) as a distance measure. We find that Bayesian deep networks from the literature can exhibit predictions that are close to Gaussian processes. To demonstrate this, we systematically compare exact Gaussian process inference with ‘gold standard’ MCMC inference for Bayesian neural networks.
+
+Our work is of relevance to the theoretical understanding of neural network initialisation and dynamics. It is also important in the area of Bayesian deep networks because it demonstrates that Gaussian process behaviour can arise in more situations of practical interest than previously thought. If this behaviour is desired then Gaussian process inference (exact and approximate) should also be considered. In some scenarios, the behaviour may not be desired because it implies a lack of a hierarchical representation. We therefore highlight promising ideas from the literature to prevent such behaviour.
+
+# 1.2 RELATED WORK
+
+The case of random neural networks with one hidden layer was studied by Neal (1996). Cho & Saul (2009) provided analytic expressions for single layer kernels including those corresponding to a rectified linear unit (ReLU). They also studied recursive kernels designed to ‘mimic computation in large, multilayer neural nets’. As discussed in Section 3 they arrived at the correct kernel recursion through an erroneous argument. Such recursive kernels were later used with empirical success in the Gaussian process literature (Krauth et al., 2017), with a similar justification to that of Cho and Saul. The first case we are aware of using a Gaussian process construction with more than one hidden layer is the work of Hazan & Jaakkola (2015). Their contribution is similar in content to Lemma 1 discussed here, and the work has had increasing interest from the kernel community (Mitrovic et al., 2017). Recent work from Daniely et al. (2016) uses the concept of ‘computational skeletons’ to give concentration bounds on the difference in the second order moments of large finite networks and their kernel analogue, with strong assumptions on the inputs. The Gaussian process view given here, without strong input assumptions, is related but concerns not just the first two moments of a random network but the full distribution. As such the theorems we obtain are distinct. A less obvious connection is to the recent series of papers studying deep networks using a mean field approximation (Poole et al., 2016; Schoenholz et al., 2017). In those papers a second order approximation gives equivalent behaviour to the kernel recursion. By contrast, in this paper the claim is that the behaviour emerges as a consequence of increasing width and is therefore something that needs to be proved. Another surprising connection is to the analysis of self-normalizing neural networks (Klambauer et al., 2017). In their analysis the authors assume that the hidden layers are wide in order to invoke the central limit theorem. The premise of the central limit theorem will only hold approximately in layers after the first one and this theoretical barrier is something we discuss here. An area that is less related than might be expected is that of ‘Deep Gaussian Processes’ (DGPs) (Damianou & Lawrence, 2013). As will be discussed in Section 6, narrow intermediate representations mean that the marginal behaviour is not close to that of a Gaussian process. Duvenaud et al. (2014) offer an analysis that largely applies to DGPs though they also study the Cho and Saul recursion with the motivating argument from the original paper.
+
+# 2 THE DEEP WIDE LIMIT
+
+We consider a fully connected network as shown in Figure 1. The inputs and outputs will be real valued vectors of dimension $M$ and $L$ respectively. The network is fully connected. The initial step and recursion are standard. The initial step is:
+
+$$
+f _ { i } ^ { ( 1 ) } ( x ) = \sum _ { j = 1 } ^ { M } w _ { i , j } ^ { ( 1 ) } x _ { j } + b _ { i } ^ { ( 1 ) } .
+$$
+
+![](images/56d90efa2de26546baa234d0d0459bec2784c6ff5bbf1566cbb111c7031834a7.jpg)  
+Figure 1: In this paper we consider fully connected feedforward networks with more than one hidden layer. We call the pre-nonlinearity an activation and post-nonlinearity an activity. As the network becomes increasingly wide the distribution of the marginal distributions of the activations at each layer and of the output will become close to a Gaussian process in a sense described in the text.
+
+We make the functional dependence on $x$ explicit in our notation as it will help clarify what follows. For a network with $D$ hidden layers the recursion is, for each $\mu = 1 , \ldots , D$ ,
+
+$$
+\begin{array} { c } { { g _ { i } ^ { ( \mu ) } ( x ) = \displaystyle { \phi ( f _ { i } ^ { ( \mu ) } ( x ) ) } } } \\ { { { f _ { i } ^ { ( \mu + 1 ) } ( x ) = \displaystyle { \sum _ { j = 1 } ^ { H _ { \mu } } w _ { i , j } ^ { ( \mu + 1 ) } g _ { j } ^ { ( \mu ) } ( x ) + b _ { i } ^ { ( \mu + 1 ) } } , } } } \end{array}
+$$
+
+so that $f ^ { ( D + 1 ) } ( x )$ is the output of the network given input $x$ . $\phi$ denotes the non-linearity. In all cases the equations hold for each value of $i$ ; $i$ ranges between 1 and $H _ { \mu }$ in Equation (2), and between 1 and $H _ { \mu + 1 }$ in Equation (3) except in the case of the final activation where the top value is $L$ . The network could of course be modified to be probability simplex-valued by adding a softmax at the end.
+
+A distribution on the parameters of the network will be assumed. Conditional on the inputs, this induces a distribution on the activations and activities. In particular we will assume independent normal distributions on the weights and biases
+
+$$
+\begin{array} { r } { w _ { i , j } ^ { ( \mu ) } \sim \mathcal { N } ( 0 , C _ { w } ^ { ( \mu ) } ) \mathrm { ~ i n d e p } } \\ { b _ { i } ^ { ( \mu ) } \sim \mathcal { N } ( 0 , C _ { b } ^ { ( \mu ) } ) \mathrm { ~ i n d e p } . } \end{array}
+$$
+
+We will be interested in the behaviour of this network as the widths $H _ { \mu }$ becomes large. The weight variances for $\mu \geq 2$ will be scaled according to the width of the network to avoid a divergence in the variance of the activities in this limit. As will become apparent, the appropriate scaling is
+
+$$
+C _ { w } ^ { ( \mu ) } = \frac { \hat { C } _ { w } ^ { ( \mu ) } } { H _ { \mu } } \mu \geq 2 .
+$$
+
+The assumption is that $\hat { C } _ { w } ^ { ( \mu ) }$ will remain fixed as we take the limit. Neal (1996) analysed this problem for $D = 1$ , showing that as $H _ { 1 } \to \infty$ , the values of $f _ { i } ^ { ( 2 ) } ( x )$ , the output of the network in this case, converge to a certain multi-output Gaussian process if the activities have bounded variance.
+
+Since our approach relies on the multivariate central limit theorem we will arrange the relevant terms into (column) vectors to make the linear algebra clearer. Consider any two inputs $x$ and $x ^ { \prime }$ and all output functions ranging over the index $i$ . We define the vector $f ^ { ( 2 ) } ( x )$ of length $L$ whose elements are the numbers $f _ { i } ^ { ( 2 ) } ( x )$ . We define $f ^ { ( 2 ) } ( x ^ { \prime } )$ similarly. For the weight matrices defined by $w _ { i , j _ { . } } ^ { ( \mu ) }$ fo r fixed we use a ‘placeholder’ index to return column and row vectors from the weight matrices. In particular $w _ { j , \cdot } ^ { ( 1 ) }$ denotes row $j$ of the weight matrix at depth 1. Similarly, $w _ { \cdot , j } ^ { ( 2 ) }$ denotes column $j$ at depth 2. The biases are given as column vectors and . Finally we concatenate the two vectors $f ^ { ( 2 ) } ( x )$ and $f ^ { ( 2 ) } ( x ^ { \prime } )$ into a single column vector $F ^ { ( 2 ) }$ of size $2 L$ . The vector in question takes the form
+
+$$
+F ^ { ( 2 ) } = \binom { f ^ { ( 2 ) } ( x ) } { f ^ { ( 2 ) } ( x ^ { \prime } ) } = \binom { b ^ { ( 2 ) } } { b ^ { ( 2 ) } } + \sum _ { j = 1 } ^ { H _ { 1 } } \binom { w _ { * , j } ^ { ( 2 ) } \phi ( w _ { j , * } ^ { ( 1 ) } x + b _ { j } ^ { ( 1 ) } ) } { w _ { * , j } ^ { ( 2 ) } \phi ( w _ { j , * } ^ { ( 1 ) } x ^ { \prime } + b _ { j } ^ { ( 1 ) } ) }
+$$
+
+The benefit of writing the relation in this form is that the applicability of the multivariate central limit theorem is immediately apparent. Each of the vector terms on this right hand side is independent and identically distributed conditional on the inputs $x$ and $x ^ { \prime }$ . By assumption, the activities have bounded variance. The scaling we have chosen on the variances is precisely that required to ensure the applicability of the theorem. Therefore as $H$ becomes large $F ^ { ( 2 ) }$ converges in distribution to a multivariate normal distribution. The limiting normal distribution is fully specified by its first two moments. Defining $\gamma \sim \mathcal { N } ( 0 , C _ { b } ^ { ( 1 ) } ) , \epsilon \sim \mathcal { N } ( \bar { 0 } , C _ { w } ^ { ( 1 ) } I _ { M } )$ , the moments in question are:
+
+$$
+\begin{array} { r l } & { \mathbb { E } \Big [ f _ { i } ^ { ( 2 ) } ( x ) \Big ] = 0 } \\ & { \mathbb { E } \Big [ f _ { i } ^ { ( 2 ) } ( x ) f _ { j } ^ { ( 2 ) } ( x ^ { \prime } ) \Big ] = \delta _ { i , j } \Big [ \hat { C } _ { w } ^ { ( 2 ) } \mathbb { E } _ { \epsilon , \gamma } \big [ \phi ( \epsilon ^ { T } x + \gamma ) \phi ( \epsilon ^ { T } x ^ { \prime } + \gamma ) \big ] + C _ { b } ^ { ( 2 ) } \Big ] } \end{array}
+$$
+
+Note that we could have taken a larger set of input points to give a larger vector $F$ and again we would conclude that this vector converged in distribution to a multivariate normal distribution. More formally, we can consider the set of possible inputs as an index set. A set of consistent finite dimensional Gaussian distributions on an index set corresponds to a Gaussian process by the Kolmogorov extension theorem. The Gaussian process in question is a distribution over functions defined on the product $\sigma$ -algebra, which has the relevant finite dimensional distributions as its marginals.
+
+In the case of a multivariate normal distribution a set of variables having a covariance of zero implies that the variables are mutually independent. Looking at Equation (9), we see that the limiting distribution has independence between different components $i , j$ of the output. Combining this with the recursion (2), we might intuitively suggest that the next layer also converges to a multivariate normal distribution in the limit of large $H _ { \mu }$ . Indeed we state the following lemma, which we attribute to Hazan & Jaakkola (2015):
+
+Lemma 1 (Normal recursion). If the activations of a previous layer are normally distributed with moments:
+
+$$
+\begin{array} { c } { { \mathbb { E } \left[ f _ { i } ^ { ( \mu - 1 ) } ( x ) \right] = 0 } } \\ { { \mathbb { E } \left[ f _ { i } ^ { ( \mu - 1 ) } ( x ) f _ { j } ^ { ( \mu - 1 ) } ( x ^ { \prime } ) \right] = \delta _ { i , j } K ( x , x ^ { \prime } ) , } } \end{array}
+$$
+
+Then under the recursion (2) and as $H \to \infty$ the activations of the next layer converge in distribution to a normal distribution with moments
+
+$$
+\begin{array} { c } { { \mathbb { E } \left[ f _ { i } ^ { ( \mu ) } ( x ) \right] = 0 } } \\ { { \mathbb { E } \left[ f _ { i } ^ { ( \mu ) } ( x ) f _ { j } ^ { ( \mu ) } ( x ^ { \prime } ) \right] = \delta _ { i , j } \left[ \hat { C } _ { w } ^ { ( \mu ) } \mathbb { E } _ { ( \epsilon _ { 1 } , \epsilon _ { 2 } ) \sim \mathcal { N } ( 0 , K ) } [ \phi ( \epsilon _ { 1 } ) \phi ( \epsilon _ { 2 } ) ] + C _ { b } ^ { ( \mu ) } \right] } } \end{array}
+$$
+
+where $K$ is a $2 \times 2$ matrix containing the input covariances.
+
+Unfortunately the lemma is not sufficient to show that the joint distribution of the activations of higher layers converge in distribution to a multivariate normals. This is because for finite $H$ the input activations do not have a multivariate normal distribution - this is only attained (weakly or in distribution) in the limit. It could be the case that the rate at which the limit distribution is attained affects the distribution in subsequent layers. We are able to offer the following theorem rigorously:
+
+Theorem 1. Consider a Bayesian deep neural network of the form in Equations (1) and (2) using ReLU activation functions. Then there exist strictly increasing width functions $h _ { \mu } : \mathbb { N } \mapsto \mathbb { N }$ such that $H _ { 1 } = h _ { 1 } ( n ) , \dots , H _ { D } = h _ { D } ( n )$ , and for any countable input set $( x [ i ] ) _ { i = 1 } ^ { \infty }$ , the distribution of the output of the network converges in distribution to a Gaussian process as $n \to \infty$ .
+
+A proof is included in the appendix. We conjecture that a more general theorem will hold. In particular we expect that the width functions $h _ { \mu }$ can be taken to be the identity and that the nonlinearity can be extended to monotone functions with well behaved tails. Our conjecture is based on the intuition from Lemma 1 and from our experiments, in which we always take the width function to be the identity.
+
+# 3 SPECIFIC KERNELS UNDER RECURSION
+
+Cho & Saul (2009) suggest a family of kernels based on a recurrence designed to ‘mimic computation in large, multilayer neural nets’. It is therefore of interest to see how this relates to deep wide Gaussian processes. A kernel may be associated with a feature mapping $\Phi ( x )$ such that $K ( x , x ^ { \prime } ) = \Phi ( { \bar { x } } ) \cdot \Phi ( x ^ { \prime } )$ . Cho and Saul define a recursive kernel through a new feature mapping by compositions such as $\Phi ( \Phi ( x ) )$ . However this cannot be a legitimate way to create a kernel because such a composition represents a type error. There is no reason to think the output dimension of the function $\Phi$ matches the input dimension and indeed the output dimension may well be infinite. Nevertheless, the paper provides an elegant solution to a different task: it derives closed form solution to the recursion from Lemma 1 (Hazan & Jaakkola, 2015) for the special case
+
+$$
+\phi ( u ) = \Theta ( u ) u ^ { r } \mathrm { f o r } r = 0 , 1 , 2 , 3 ,
+$$
+
+where $\Theta$ is the Heaviside step function. Specifically, the recursive approach of Cho & Saul (2009) can be adapted by using the fact that $u ^ { \top } z$ for $z \stackrel { \cdot } { \sim } \mathcal { N } ( 0 , L L ^ { \top } )$ is equivalent in distribution to $( L ^ { \top } u ) ^ { \top } \varepsilon$ with $\varepsilon \sim \mathcal { N } ( 0 , I )$ , and by optionally augmenting $u$ to incorporate the bias. Since $r = 1$ corresponds to rectified linear units we apply this analytic kernel recursion in all of our experiments.
+
+# 4 MEASURING CONVERGENCE USING MAXIMUM MEAN DISCREPANCY
+
+In this section we use the kernel based two sample tests of Gretton et al. (2012) to empirically measure the similarity of finite random neural networks to their Gaussian process analogues. The maximum mean discrepancy (MMD) between two distributions $\mathcal { P }$ and $\mathcal { Q }$ is defined as:
+
+$$
+\mathcal { M } \mathcal { M } \mathcal { D } ( \mathcal { P } , \mathcal { Q } , \mathcal { H } ) : = \operatorname* { s u p } _ { | | h | | \varkappa \leq 1 } \bigg [ \mathbb { E } _ { \mathcal { P } } [ h ] - \mathbb { E } _ { \mathcal { Q } } [ h ] \bigg ]
+$$
+
+where $\mathcal { H }$ denotes a reproducing kernel Hilbert space and $| | \cdot | | _ { \mathcal { H } }$ denotes the corresponding norm. It gives the biggest possible difference between expectations of a function under the two distributions under the constraint that the function has Hilbert space norm less than or equal to one. We used the unbiased estimator of squared MMD given in Equation (3) of Gretton et al. (2012).
+
+In this experiment and all those that follow we take weight variance parameters $\hat { C } _ { w } ^ { ( \mu ) } = 0 . 8$ and bias variance $C _ { b } = 0 . 2$ . We took 10 standard normal input points in 4 dimensions and pass them through 2000 independent random neural networks drawn from the distribution discussed in this paper. This was then compared to 2000 samples drawn from the corresponding Gaussian process distribution. The experiment was performed with different numbers of hidden layers and numbers of units per hidden layer. We repeated each experiment 20 times which allows us to reduce variance in our results and give a simple estimate of measurement error. The experiments use an RBF kernel for the MMD estimate with lengthscale $1 / 2$ . In order to help give an intuitive sense of the distances involved we also include a comparison between two Gaussian processes with isotropic RBF kernels using the same MMD distance measure. The kernel length scales for this pair of ‘calibration’ Gaussian√ processes are taken to be $l$ and $2 l$ , where the characteristic length scale $l = \sqrt { 8 }$ is chosen to be sensible for the standard Normal input distribution on the four dimensional space.
+
+![](images/1fe372eec3c496c30cf04f1cbff79d1e581ad4fc81f2faf3611a67bdc1360249.jpg)  
+Figure 2: A comparison of finite random neural networks to their corresponding Gaussian process analogue using an (RBF) kernel estimator of the squared maximum mean discrepancy (MMD). The results are consistent with the emergence of Gaussian process behaviour as the networks become wide. The red dashed line is for calibration and denotes the squared MMD between two Gaussian processes with isotropic RBF kernels and length scales $l$ and $2 l$ where $l = { \sqrt { 8 } }$ is the characteristic length scale of the input space (see text).
+
+The results of the experiment are shown in Figure 2. We see that for each fixed depth the network converges towards the corresponding Gaussian process as the width increases. For the same number of hidden units per layer, the MMD distance between the networks and their Gaussian process analogue becomes higher as depth increases. The rate of convergence to the Gaussian process is slower as the number of hidden layers is increased.
+
+# 5 COMPARING BAYESIAN DEEP NETWORKS TO GAUSSIAN PROCESSES
+
+In this section we compare the behaviour of finite Bayesian deep networks of the form considered in this paper with their Gaussian process analogues. If we make the networks wide enough the agreement will be very close. It is also of interest, however, to consider the behaviour of networks actually used in the literature, so we use 3 hidden layers and 50 hidden units which is typical of the networks used by Hernandez-Lobato & Adams (2015). Fully connected Bayesian deep networks ´ with finite variance priors on the weights have also been considered in other works (Graves, 2011; Hernandez-Lobato et al., 2016; Blundell et al., 2015), though the specific details vary. We use rec- ´ tified linear units and correct the variances to avoid a loss of prior variance as depth is increased. Our general strategy was to compare exact Gaussian process inference against expensive ‘gold standard’ Markov Chain Monte Carlo (MCMC) methods. We choose the latter because used correctly it works well enough to largely remove questions of posterior approximation quality from the calculus of comparison. It does mean however that our empirical study does not extend to datasets which are large in terms of number of data points or dimensionality, where such inference is challenging. We therefore sound a note of caution about extrapolating our empirical finite network conclusions too confidently to this domain. On the other hand, lower dimensional, prior dominated problems are generally regarded as an area of strength for Bayesian approaches and in this context our results are directly relevant.
+
+We computed the posterior moments by the two different methods on some example datasets. For the MCMC we used Hamiltonian Monte Carlo (HMC) (Neal, 2010) updates interleaved with elliptical slice sampling (Murray et al., 2010). We considered a simple one dimensional problem and a two dimensional real valued embedding of the four data point XOR problem. We see in Figures 3 and 4 (left) that the agreement in the posterior moments between the Gaussian process and the Bayesian deep network is very close.
+
+A key quantity of interest in Bayesian machine learning is the marginal likelihood. It is the normalising constant of the posterior distribution and gives a measure of the model fit to the data. For a Bayesian neural network, it is generally very difficult to compute, but with care and computational time it can be approximated using Hamiltonian annealed importance sampling (Sohl-Dickstein & Culpepper, 2012). The log-importance weights attained in this way constitute a stochastic lower bound on the marginal likelihood (Grosse et al., 2015). Figure 4 (right) shows the result of such an experiment compared against the (extremely cheap) Gaussian process marginal likelihood computation on the XOR problem. The value of the log-marginal likelihood computed in the two different ways agree to within a single nat which is negligible from a model selection perspective (Grosse et al., 2015).
+
+Predictive log-likelihood is a measure of the quality of probabilistic predictions given by a Bayesian regression method on a test point. To compare the two models we sampled 10 standard normal train and test points in 4 dimensions and passed them through a random network of the type under study to get regression targets. We then discarded the true network parameters and compared the predictions of posterior inference between the two methods. We also compared the marginal predictive distributions of a latent function value. Figure 5 shows the results. We see that the correspondence in predictive log-likelihood is close but not exact. Similarly the marginal function values are close to those of a Gaussian process but are slightly more concentrated.
+
+![](images/4950e59034f9320aa1668f2a594bbaf4fe2518623461ab36978858afadb98527.jpg)  
+Figure 3: A comparison between Bayesian posterior inference in a Bayesian deep neural network and posterior inference in the analogous Gaussian process. The neural network has 3 hidden layers and 50 units per layer. The lines show the posterior mean and two $\sigma$ credible intervals.
+
+![](images/44b971680960ba86101b959babfbdc212734e55b92591e618111d6cd55e833f6.jpg)  
+Figure 4: A comparison between posterior inference for a Gaussian process and a Bayesian deep network for a real value embedding of the XOR function. Left and centre: The two posterior means. The mean absolute different between the two posterior estimate grids is 0.027. Right: Kernel density estimate of the log weights from annealed importance sampling on a Bayesian deep network compared to the analogous Gaussian process marginal likelihood shown by the vertical line. The neural network has 3 hidden layers and 50 units per layer.
+
+![](images/563534ef8e0cdd0d495d680cfdbb810e6430a114d8fb62e43bea128473d92fe9.jpg)  
+Figure 5: A comparison of the predictive distributions of a Bayesian deep network and a Gaussian process on a randomly generated test case. Left: the per point log-densities of the two models. Right: a randomly selected predictive marginal distribution for the latent function on a randomly selected test point.
+
+# 6 AVOIDING GAUSSIAN PROCESS BEHAVIOUR
+
+When using deep Bayesian neural networks as priors, the emergence of Gaussian priors raises important questions in the cases where it is applicable, even if one sets aside questions of computational tractability. It has been argued in the literature that there are important cases where kernel machines with local kernels will perform badly (Bengio et al., 2005). The analysis applies to the posterior mean of a Gaussian process. The emergent kernels in our case are hyperparameter free. Although they do not meet the strict definition of what could be considered ‘local’ the fact remains that any Gaussian process with a fixed kernel does not use a learnt hierarchical representation. Such representations are widely regarded to be essential to the success of deep learning. There is relevant literature here on learning the representation of a standard, usually structured, network composed with a Gaussian process (Wilson et al., 2016a;b; Al-Shedivat et al., 2017). This differs from the assumed paradigm of this paper, where all model complexity is specified probabilistically and we do not assume convolutional, recurrent or other problem specific structure.
+
+Within this paradigm, the question therefore arises as to what can be done to avoid marginal Gaussian process behaviour if it is not desired. Speaking loosely, to stop the onset of the central limit theorem and the approximate analogues discussed in this paper one needs to make sure that one or more of its conditions is far from being met. Since the chief conditions on the summands are independence, bounded variance and many terms, violating these assumptions will remove Gaussian process behaviour. Deep Gaussian processes (Damianou & Lawrence, 2013) are not close to standard Gaussian processes marginally because they are typically used with narrow intermediate layers. It can be challenging to choose the precise nature of these narrow layers a priori. Neal (1996) suggests using networks with infinite variance in the activities. With a single hidden layer and correctly scaled, these networks become alpha stable processes in the wide limit. Neal also discusses variants that destroy independence by coupling weights. Our results about the emergence of Gaussian processes even with more than one hidden layer mean these ideas are of considerable interest going forward.
+
+# 7 CONCLUSIONS
+
+Studying the limiting behaviour of distributions on feedforward networks has been a fruitful avenue for understanding these models historically. In this paper we have extended the state of knowledge about the wide limit, including for networks with more than one hidden layer. In particular, we have exhibited limit sequences of networks that converge in distribution to Gaussian processes with a certain recursively defined kernel. Our empirical study using MMD suggests that this behaviour is exhibited in a variety of models of size comparable to networks used in the literature. This led us to juxtapose finite Bayesian neural networks with their Gaussian process analogues, finding that the agreement in terms of key predictors is close empirically. If this Gaussian process behaviour is desired then exact and approximate inference using the analytic properties of Gaussian processes should be considered as an alternative to neural network inference. Since Gaussian processes have an equivalent flat representation then in the context of deep learning the behaviour may well not be desired and steps should be taken to avoid it.
+
+We view these results as a new opportunity to further the understanding of neural networks in the work that follows. Initialisation and learning dynamics are crucial topics of study in modern deep learning which require that we understand random networks. Bayesian neural networks should offer a principled approach to generalisation but this relies on successfully approximating a clearly understood prior. In illustrating the continued importance of Gaussian processes as limit distributions, we hope that our results will further research in these broader areas.
+
+# 8 ACKNOWLEDGEMENTS
+
+We wish to thank Neil Lawrence for helpful conversations. We also thank the anonymous reviewers for their insights. Alexander Matthews and Zoubin Ghahramani acknowledge the support of EPSRC Grant EP/N014162/1 and EPSRC Grant EP/N510129/1 (The Alan Turing Institute). Jiri Hron holds a Nokia CASE Studentship. Mark Rowland acknowledges support by EPSRC grant EP/L016516/1 for the Cambridge Centre for Analysis. Richard E. Turner is supported by Google as well as EPSRC grants EP/M0269571 and EP/L000776/1.
+
+# REFERENCES
+
+Maruan Al-Shedivat, Andrew G. Wilson, Yunus Saatchi, Zhiting Hu, and Eric P. Xing. Learning Scalable Deep Kernels with Recurrent Structure. Journal of Machine Learning Research (JMLR), 2017.
+
+Yoshua Bengio, Olivier Delalleau, and Nicolas Le Roux. The Curse of Dimensionality for Local Kernel Machines. Technical Report 1258, Departement d’informatique et recherche ´ operationnelle, Universit´ e de Montr´ eal, 2005.´
+
+Vidmantas K. Bentkus. On the Dependence of the Berry-Esseen bound on Dimension. Journal of Statistical Planning and Inference, 2003.
+
+Patrick Billingsley. Convergence of Probability Measures. John Wiley & Sons Inc., Second edition, 1999.
+
+Charles Blundell, Julien Cornebise, Koray Kavukcuoglu, and Daan Wierstra. Weight Uncertainty in Neural Networks. International Conference on Machine Learning (ICML), 2015.
+
+Youngmin Cho and Lawrence K. Saul. Kernel Methods for Deep Learning. Advances in Neural Information Processing Systems (NIPS), 2009.
+
+Andreas C. Damianou and Neil D. Lawrence. Deep Gaussian Processes. International Conference on Artificial Intelligence and Statistics (AISTATS), 2013.
+
+Amit Daniely, Roy Frostig, and Yoram Singer. Toward Deeper Understanding of Neural Networks: The Power of Initialization and a Dual View on Expressivity. Advances in Neural Information Processing Systems (NIPS), 2016.
+
+David Duvenaud, Oren Rippel, Ryan P. Adams, and Zoubin Ghahramani. Avoiding Pathologies in very Deep Networks. International Conference on Artificial Intelligence and Statistics (AISTATS), 2014.
+
+Alex Graves. Practical Variational Inference for Neural Networks. Advances in Neural Information Processing Systems (NIPS), 2011.
+
+Arthur Gretton, Karsten M. Borgwardt, Malte J. Rasch, Bernhard Scholkopf, and Alexander Smola.¨ A Kernel Two-sample test. Journal of Machine Learning Research (JMLR), 2012.
+
+Roger B. Grosse, Zoubin Ghahramani, and Ryan P. Adams. Sandwiching the marginal likelihood using bidirectional Monte Carlo. ArXiv e-prints, November 2015.
+
+Tamir Hazan and Tommi Jaakkola. Steps Toward Deep Kernel Methods from Infinite Neural Networks. ArXiv e-prints, August 2015.
+
+Jose M. Hern ´ andez-Lobato and Ryan P. Adams. Probabilistic Backpropagation for Scalable Learn- ´ ing of Bayesian Neural Networks. International Conference on Machine Learning (ICML), 2015.
+
+Jose M. Hern ´ andez-Lobato, Yingzhen Li, Mark Rowland, Thang Bui, Daniel Hern ´ andez-Lobato, ´ and Richard E. Turner. Black-box alpha divergence minimization. International Conference on Machine Learning (ICML), 2016.
+
+Gunter Klambauer, Thomas Unterthiner, Andreas Mayr, and Sepp Hochreiter. Self-Normalizing ¨ Neural Networks. CoRR, abs/1706.02515, 2017.
+
+Karl Krauth, Edwin V. Bonilla, Kurt Cutajar, and Maurizio Filippone. AutoGP: Exploring the capabilities and limitations of Gaussian Process models. Conference on Uncertainty in Artificial Intelligence (UAI), 2017.
+
+Jovana Mitrovic, Dino Sejdinovic, and Yee Whye Teh. Deep Kernel Machines via the Kernel Reparametrization Trick. In International Conference on Learning Representations (ICLR) Workshop Track, 2017.
+
+Iain Murray, Ryan P. Adams, and David J. C. MacKay. Elliptical Slice Sampling. International Conference on Artificial Intelligence and Statistics (AISTATS), 2010.
+
+Radford M. Neal. Bayesian Learning for Neural Networks. Springer, 1996.
+
+Radford M. Neal. MCMC using Hamiltonian Dynamics. Handbook of Markov Chain Monte Carlo, 2010.
+
+Ben Poole, Subhaneil Lahiri, Maithreyi Raghu, Jascha Sohl-Dickstein, and Surya Ganguli. Exponential expressivity in Deep Neural Networks through Transient Chaos. Advances in Neural Information Processing Systems (NIPS), 2016.
+
+Carl E. Rasmussen and Christopher K. I. Williams. Gaussian Processes for Machine Learning. The MIT Press, 2006.
+
+Samuel S. Schoenholz, Justin Gilmer, Surya Ganguli, and Jascha Sohl-Dickstein. Deep Information Propagation. International Conference on Learning Representations (ICLR), 2017.
+
+Jascha Sohl-Dickstein and Benjamin J. Culpepper. Hamiltonian Annealed Importance Sampling for partition function estimation. CoRR, abs/1205.1925, 2012.
+
+Christopher K. I. Williams. Computing with Infinite Networks. Advances in Neural Information Processing Systems (NIPS), 1998.
+
+Andrew G. Wilson, Zhiting Hu, Ruslan Salakhutdinov, and Eric P. Xing. Deep Kernel Learning. International Conference on Artificial Intelligence and Statistics (AISTATS), 2016a.
+
+Andrew G. Wilson, Zhiting Hu, Ruslan R. Salakhutdinov, and Eric P. Xing. Stochastic Variational Deep Kernel Learning. Advances in Neural Information Processing Systems (NIPS), 2016b.
+
+# A PROOF OF MAIN THEOREM
+
+# A.1 STATEMENT OF THEOREM AND NOTATION
+
+In this section, we provide a proof of the main theorem of the paper, which we begin by recalling.
+
+Theorem 1. Consider a Bayesian deep neural network of the form in Equations (1) and (2) using ReLU activation functions. Then there exist strictly increasing width functions $h _ { \mu } : \mathbb { N } \mapsto \mathbb { N }$ such that $H _ { 1 } = h _ { 1 } ( n ) , \ldots , H _ { D } = h _ { D } ( n )$ , and for any countable input set $( x [ i ] ) _ { i = 1 } ^ { \infty }$ , the distribution of the output of the network converges in distribution to a Gaussian process as $n \to \infty$ .
+
+The theorem is proven via use of the propositions that follow below. The broad structure of the proof is to use a particular variant of the Berry-Esseen inequality to upper bound how far each layer is from a multivariate normal distribution, and then to inductively propagate these inequalities through the network, leading to a bound on the distance between the output of the network for a collection of input points, and a multivariate Gaussian distribution. These notions will be made precise below. We begin in Section A.2 by stating the propositions that will be used in the proof of Theorem 1, but first establish notation that will be used in the remainder of the appendix.
+
+Given a finite set of inputs $x [ 1 ] , \ldots , x [ n ] \in \mathbb { R } ^ { M }$ , we will write:
+
+• $f ^ { ( \mu ) } ( \mathbf { x } )$ for the random variables $( f ^ { ( \mu ) } ( x [ i ] ) ) _ { i = 1 } ^ { n }$ collectively taking values in $\mathbb { R } ^ { n H _ { \mu } }$ ;   
+• $f _ { j } ^ { ( \mu ) } ( \mathbf { x } )$ for the random variables $( f _ { j } ^ { ( \mu ) } ( x [ i ] ) ) _ { i = 1 } ^ { n }$ collectively taking values in $\mathbb { R } ^ { n }$ ;   
+• $g ^ { ( \mu ) } ( \mathbf { x } )$ for the random variables $( g ^ { ( \mu ) } ( x [ i ] ) ) _ { i = 1 } ^ { n }$ collectively taking values in $\mathbb { R } ^ { n H _ { \mu } }$ ;   
+• $g _ { j } ^ { ( \mu ) } ( \mathbf { x } )$ for the random variables $( g _ { j } ^ { ( \mu ) } ( x [ i ] ) ) _ { i = 1 } ^ { n }$ collectively taking values in $\mathbb { R } ^ { n }$ ;
+
+Throughout, if $U _ { 1 } , U _ { 2 }$ are random variables taking in values in some Euclidean space $\mathbb { R } ^ { d }$ , we will define
+
+$$
+d ( U _ { 1 } , U _ { 2 } ) = \operatorname* { s u p } _ { \stackrel { A \subseteq \mathbb { R } ^ { d } } { A \mathrm { ~ c o n v e x } } } \left| \mathbb { P } ( U _ { 1 } \in A ) - \mathbb { P } ( U _ { 2 } \in A ) \right| .
+$$
+
+Note that convergence of a sequence of random variables in this metric implies convergence in distribution.
+
+We will also consider multivariate normal distributions $( Z _ { j } ^ { ( \mu ) } ( x [ i ] ) | j = 1 , \ldots , H _ { \mu } , i = 1 , \ldots , n )$ with covariance matrices of block diagonal form, such that
+
+$$
+\operatorname { C o v } ( Z _ { k } ^ { ( \mu ) } ( x [ a ] ) , Z _ { l } ^ { ( \mu ) } ( x [ b ] ) ) = 0 { \mathrm { ~ f o r ~ d i s t i n c t ~ } } k , l \in \{ 1 , \ldots , H _ { \mu } \} , \quad { \mathrm { f o r ~ a l l ~ } } x [ a ] , x [ b ] .
+$$
+
+To avoid writing this in full every time it is required, we will refer to this condition as blockwise independence with respect to the index $j$ . We will avoid specification of all covariance values, deferring to the expression (13) given in the main paper. Finally, to simplify notation, we will assume that the network output is one-dimensional. Our proof trivially extends to arbitrary finite output dimension where the limiting distribution is a coordinate-wise independent multivariate GP.
+
+# A.2 SUPPORTING RESULTS
+
+Proposition 1. Let $\varepsilon > 0$ , and $x [ 1 ] , \ldots , x [ n ] \in \mathbb { R } ^ { M }$ . Let $\mu \in \{ 2 , . . . , D + 1 \}$ , and let $H _ { k } = 2 ^ { H _ { k + 1 } ^ { 2 } }$ for $k = 1 , \ldots , D - 1$ . Then for $H _ { D }$ sufficiently large, suppose the condition
+
+$$
+\begin{array} { r } { d \big ( f ^ { ( \mu - 1 ) } ( \mathbf { x } ) , Z ^ { ( \mu - 1 ) } ( \mathbf { x } ) \big ) \leq 2 ^ { - ( ( D + 1 ) - ( \mu - 1 ) ) - n \sum _ { k = \mu - 1 } ^ { D } H _ { k } } \varepsilon , } \end{array}
+$$
+
+holds, where $Z ^ { ( \mu - 1 ) } ( { \bf x } ) = ( Z _ { j } ^ { ( \mu - 1 ) } ( x [ i ] ) \vert j = 1 , \dots , H _ { \mu - 1 } , \ i = 1 , \dots , n )$ is mean-zero multivariate normal, with blockwise independence with respect to the index $j$ . Then we have
+
+$$
+\begin{array} { r } { d ( f ^ { ( \mu ) } ( \mathbf { x } ) , Z ^ { ( \mu ) } ( \mathbf { x } ) ) \leq 2 ^ { - ( ( D + 1 ) - \mu ) - n \sum _ { k = \mu } ^ { D } H _ { k } } \varepsilon , } \end{array}
+$$
+
+where $Z _ { . } ^ { ( \mu ) } ( { \bf x } ) = ( Z _ { j . } ^ { ( \mu ) } ( x [ i ] ) \vert j = 1 , \dots , H _ { \mu }$ , $i = 1 , \ldots , n ,$ ) is mean-zero multivariate normal, with blockwise independence with respect to the index $j$ .
+
+Proposition 2. Let $\varepsilon > 0$ , and $x [ 1 ] , \ldots , x [ n ] \in \mathbb { R } ^ { M }$ . If $H _ { k } = 2 ^ { H _ { k + 1 } ^ { 2 } }$ for $k = 1 , \ldots , D - 1$ , then for $H _ { D }$ sufficiently large, we have
+
+$$
+d ( f ^ { ( D + 1 ) } ( { \bf x } ) , Z ( { \bf x } ) ) \le \varepsilon ,
+$$
+
+where $Z ( \mathbf { x } )$ is a mean-zero multivariate normal random variable.
+
+In establishing the two propositions above, the following three lemmas will be useful.
+
+Lemma 2. Let $\varepsilon > 0$ , and let $Z ^ { ( \mu - 1 ) } ( { \bf x } ) = ( Z _ { j } ^ { ( \mu - 1 ) } ( x [ i ] ) | j = 1 , \ldots , H _ { \mu - 1 }$ , $i = 1 , \ldots , n )$ be mean-zero multivariate normal, with blockwise independence with respect to the index $j$ . Let $\widetilde { g } ^ { ( \mu - 1 ) } ( \mathbf { x } ) = \phi ( Z ^ { ( \mu - 1 ) } ( \mathbf { x } ) )$ , and let $\widetilde f ^ { ( \mu ) } ( \mathbf { x } )$ be given by
+
+$$
+\widetilde { f } ^ { ( \mu ) } ( x [ i ] ) = \sum _ { j = 1 } ^ { H _ { \mu - 1 } } w _ { \star , j } ^ { ( \mu ) } \widetilde { g } _ { j } ^ { ( \mu - 1 ) } ( x [ i ] ) + b ^ { ( \mu ) } ,
+$$
+
+for $i = 1 , \ldots , n$ . Then given $\varepsilon > 0$ , if $H _ { k } = 2 ^ { H _ { k + 1 } ^ { 2 } }$ for $k = 1 , \ldots , D - 1$ , then for all sufficiently large $H _ { D }$ we have:
+
+$$
+d ( \widetilde f ^ { ( \mu ) } ( \mathbf x ) , Z ^ { ( \mu ) } ( \mathbf x ) ) \le 2 ^ { - ( ( D + 1 ) - ( \mu - 1 ) ) - n \sum _ { k = \mu } ^ { D } H _ { k } } \varepsilon ,
+$$
+
+where $Z ^ { ( \mu ) } ( { \bf x } ) = ( Z _ { j } ^ { ( \mu ) } ( x [ i ] ) | j = 1 , \ldots , H _ { \mu } , i = 1 , \ldots , n )$ is mean-zero multivariate normal, with blockwise independence with respect to the index $j$ .
+
+Lemma 3. Let $Z _ { \cdot \cdot \cdot } ^ { ( \mu - 1 ) } ( \underline { { \mathbf { x } } } ) _ { \cdot } = ( Z _ { j } ^ { ( \mu - 1 ) } ( x [ i ] ) | j = 1 , \dots , H _ { \mu - \cdot } 1 , 1 , \dots , n )$ be mean-zero multivariate normal, with blockwise independence with respect to the index $j$ , such that for some $\varepsilon > 0$ ,
+
+$$
+d ( Z ^ { ( \mu - 1 ) } ( \mathbf { x } ) , f ^ { ( \mu - 1 ) } ( \mathbf { x } ) ) \leq \varepsilon .
+$$
+
+Then, defining $\widetilde f ^ { ( \mu ) } ( \mathbf { x } )$ by
+
+$$
+\widetilde { f } ^ { ( \mu ) } ( x [ i ] ) = \sum _ { j = 1 } ^ { H _ { \mu } } w _ { \bullet , j } \phi ( Z _ { j } ^ { ( \mu - 1 ) } ( x [ i ] ) ) + b ^ { ( \mu ) } ,
+$$
+
+in the particular case where $\phi$ is the elementwise ReLU function, we have
+
+$$
+d ( \widetilde f ^ { ( \mu ) } ( \mathbf { x } ) , f ^ { ( \mu ) } ( \mathbf { x } ) ) \leq 2 ^ { n H _ { \mu - 1 } } \varepsilon .
+$$
+
+where Lemma 4. Let $\otimes$ µ denotes the Kronecker product, be iid random variables of the form $\widetilde { g } _ { j } ^ { ( \mu - 1 ) } ( \mathbf { x } )$ is defined as in $X _ { j } ~ = ~ { \widetilde { g } } _ { j } ^ { ( \mu - 1 ) } ( \mathbf { x } ) \otimes { \widetilde { w } } _ { \bullet , j } ^ { ( \mu ) }$ ejemma 2, and $\widetilde { w } _ { \bullet , j } ^ { ( \mu ) }$ $a$ multivariate normal variable taking values in $\mathbb { R } ^ { H _ { \mu } }$ with mean vector $O$ , and covariance $\hat { C } _ { w } ^ { ( \mu ) } I .$ . We denote the variance of $X _ { j }$ by $\Sigma _ { \otimes }$ and its Schur decomposition as $\Sigma _ { \otimes } = Q _ { \otimes } \Lambda _ { \otimes } Q _ { \otimes } ^ { T }$ . Then $\beta = \mathbb { E } \left[ \| Q _ { \otimes } \Lambda _ { \otimes } ^ { - 1 / 2 } Q _ { \otimes } ^ { T } X _ { j } \| ^ { 3 } \right] \leq C _ { H _ { \mu } , n } ,$ , where $C _ { H _ { \mu } , n } \in \mathbb { R }$ depends on $H _ { \mu }$ and $n$ , but is independent of $H _ { \mu - 1 }$ . Further, we have $C _ { H _ { \mu } , n } = \mathcal { O } ( H _ { \mu } ^ { 2 } n ^ { 2 } )$ .
+
+# A.3 PROOFS
+
+Proof of Lemma 2. We use a straightforward variant of a particular Berry-Esseen inequality described in Bentkus (2003). We first state this result from the literature, and then derive a straightforward variation that we will use in the sequel.
+
+Theorem 2 (From Bentkus (2003)). Let $X _ { 1 } , \ldots , X _ { n }$ be iid random variables taking values in $\mathbb { R } ^ { d }$ , with mean vector $O _ { ; }$ , identity covariance matrix, and $\beta = \mathbb { E } \left[ \| X _ { i } \| ^ { 3 } \right] < \infty .$ . Let $\begin{array} { r } { S _ { n } = \frac { 1 } { \sqrt { n } } \sum _ { i = 1 } ^ { n } X _ { i } } \end{array}$ and let $Y$ be a standard $d$ -dimensional multivariate normal random vector. Then we have
+
+$$
+\operatorname* { s u p } _ { A \subseteq \mathbb { R } ^ { d } } | \mathbb { P } ( S _ { n } \in A ) - \mathbb { P } ( Y \in A ) | \leq { \frac { 4 0 0 d ^ { 1 / 4 } \beta } { \sqrt { n } } }
+$$
+
+We need a mildly modified version of this theorem to deal with iid random vectors $X _ { 1 } , \ldots , X _ { n }$ with non-identity covariance matrices. To this end, suppose that $\Sigma$ is the (full-rank) covariance matrix of each $X _ { i }$ , with decomposition $\Sigma = R R ^ { \top }$ , for some invertible matrix $R$ ; $R$ can be obtained, for example, by using Cholesky or Schur decomposition. The random variables $R ^ { - 1 } X _ { 1 } , \ldots , R ^ { - 1 } X _ { n }$ are then iid, mean zero and with identity covariance matrices, so we may apply Theorem 2 to obtain:
+
+$$
+\operatorname* { s u p } _ { A \subseteq \mathbb { R } ^ { d } } | \mathbb { P } ( R ^ { - 1 } S _ { n } \in A ) - \mathbb { P } ( Y \in A ) | \leq \frac { 4 0 0 d ^ { 1 / 4 } \beta } { \sqrt { n } } ,
+$$
+
+where $\beta = \mathbb { E } \left[ \| R ^ { - 1 } X _ { i } \| ^ { 3 } \right] .$ . Now note that this is equivalent to
+
+$$
+\operatorname* { s u p } _ { A \subseteq \mathbb { R } ^ { d } } | \mathbb { P } ( S _ { n } \in R A ) - \mathbb { P } ( R Y \in R A ) | \leq \frac { 4 0 0 d ^ { 1 / 4 } \beta } { \sqrt { n } } ,
+$$
+
+noting that $R Y \sim N ( 0 , \Sigma )$ .
+
+Since $R$ is invertible, and recalling the definition of the distance $d$ above, this is exactly equivalent to:
+
+$$
+d ( S _ { n } , R Y ) \leq { \frac { 4 0 0 d ^ { 1 / 4 } \beta } { \sqrt { n } } } ,
+$$
+
+which is the variant of Bentkus’ result we will require in the sequel.
+
+We apply this bound to the sum
+
+$$
+\sum _ { j = 1 } ^ { H _ { \mu - 1 } } \widetilde { g } _ { j } ^ { ( \mu - 1 ) } ( \mathbf { x } ) \otimes w _ { \star , j } ^ { ( \mu ) }
+$$
+
+Noting that the summands indexed by $j$ are iid by assumption, with the expected third moment norm featuring in the Berry-Esseen inequality upper-bounded by $\beta \leq C _ { H _ { \mu } , n }$ , for some constant $C _ { H _ { \mu } , n }$ depending on $H _ { \mu }$ and $n$ , but independent of $H _ { \mu - 1 }$ (finiteness of $C _ { H _ { \mu } , n }$ follows from Lemma 4).
+
+As a consequence, we have the following bound:
+
+$$
+d \left( \sum _ { j = 1 } ^ { H _ { \mu - 1 } } \widetilde { g } _ { j } ^ { ( \mu - 1 ) } ( { \bf x } ) \otimes w _ { \star , j } ^ { ( \mu ) } , Z ^ { \prime } ( { \bf x } ) \right) \leq 4 0 0 C _ { H _ { \mu } , n } ( n H _ { \mu } ) ^ { 1 / 4 } / \sqrt { H _ { \mu - 1 } } ,
+$$
+
+where $Z ^ { \prime } ( \mathbf { x } ) = ( Z _ { j } ^ { \prime } ( x [ i ] ) | \underline { { { j } } } = 1 , \dots , H _ { \underline { { { \mu } } } }$ , $i = 1 , \ldots , n )$ is mean-zero multivariate normal, with blockwise independence with respect to the index $j$ . We wish to demonstrate that this is less than or equal to $2 ^ { - ( D - ( \mu - 1 ) ) - n \sum _ { k = \mu } ^ { D } H _ { k } } \varepsilon$ when $H _ { D }$ is sufficiently large. This is equivalent to showing that
+
+$$
+4 0 0 C _ { H _ { \mu } , n } ( n H _ { \mu } ) ^ { 1 / 4 } 2 ^ { ( ( D + 1 ) - ( \mu - 1 ) ) + n \sum _ { k = \mu } ^ { D } H _ { k } } / \sqrt { H _ { \mu - 1 } } \leq \varepsilon
+$$
+
+for all sufficiently large $H _ { D }$ . But note that with $H _ { k - 1 } = 2 ^ { H _ { k } ^ { 2 } }$ for $k = \mu , \ldots , D - 1$ , the left-hand side converges to $0$ as $H _ { D }$ increases (using the bound obtained for $C _ { H _ { \mu } , n }$ in Lemma 4), so for all $H _ { D }$ sufficiently large, we obtain
+
+$$
+\begin{array} { r } { d \left( \displaystyle \sum _ { j = 1 } ^ { H _ { \mu - 1 } } \widetilde { g } _ { j } ^ { ( \mu - 1 ) } ( \mathbf { x } ) \otimes w _ { \star , j } ^ { ( \mu ) } , Z ^ { \prime } ( \mathbf { x } ) \right) \le 2 ^ { - ( ( D + 1 ) - ( \mu - 1 ) ) - n \sum _ { k = \mu } ^ { D } H _ { k } } \varepsilon , } \end{array}
+$$
+
+as required.
+
+Adding the independent bias vector $b ^ { ( \mu ) }$ immediately yields
+
+$$
+d \left( 1 _ { n } \otimes b ^ { ( \mu ) } + \sum _ { j = 1 } ^ { H _ { \mu - 1 } } \widetilde { g } _ { j } ^ { ( \mu - 1 ) } ( \mathbf { x } ) \otimes w _ { \star , j } ^ { ( \mu ) } , Z ( \mathbf { x } ) \right) \leq 2 ^ { - ( ( D + 1 ) - ( \mu - 1 ) ) - n \sum _ { k = \mu } ^ { D } H _ { k } } \varepsilon ,
+$$
+
+where $Z ( \mathbf { x } )$ is mean-zero multivariate normal, with the same block-diagonal covariance structure as described for $Z ^ { \prime } ( \mathbf { x } )$ above, and $1 _ { n } \in \mathbb { R } ^ { n }$ is a vector of $^ { 1 }$ ’s. □
+
+Proof of Lemma 3. Let $A \subseteq \mathbb { R } ^ { n H _ { \mu } }$ be an arbitrary convex set. First, observe that we have
+
+$$
+\begin{array} { l } { \displaystyle \mathbb { P } \left( \left( 1 _ { n } \otimes b ^ { ( \mu ) } + \sum _ { j = 1 } ^ { H _ { \mu - 1 } } \phi ( \widetilde { f } _ { j } ^ { ( \mu - 1 ) } ( \mathbf { x } ) ) \otimes w _ { \star , j } ^ { ( \mu ) } \right) \in A \right) } \\ { \displaystyle = \mathbb { E } \left[ \mathbb { P } \left( \left( 1 _ { n } \otimes b ^ { ( \mu ) } + \sum _ { j = 1 } ^ { H _ { \mu - 1 } } \phi ( \widetilde { f } _ { j } ^ { ( \mu - 1 ) } ( \mathbf { x } ) ) \otimes w _ { \star , j } ^ { ( \mu ) } \right) \in A \Big | w ^ { ( \mu ) } , b ^ { ( \mu ) } \right) \right] } \\ { \displaystyle = \mathbb { E } \left[ \mathbb { P } \left( \left( \sum _ { j = 1 } ^ { H _ { \mu - 1 } } \phi ( \widetilde { f } _ { j } ^ { ( \mu - 1 ) } ( \mathbf { x } ) ) \otimes w _ { \star , j } ^ { ( \mu ) } \right) \in A - 1 _ { n } \otimes b ^ { ( \mu ) } \Big | w ^ { ( \mu ) } , b ^ { ( \mu ) } \right) \right] } \end{array}
+$$
+
+Now, note that for fixed $w ^ { ( \mu ) }$ and $b ^ { ( \mu ) }$ , the event
+
+$$
+\left\{ \left( \sum _ { j = 1 } ^ { H _ { \mu - 1 } } \phi ( \widetilde { f } _ { j } ^ { ( \mu - 1 ) } ( \mathbf { x } ) ) \otimes w _ { \star , j } ^ { ( \mu ) } \right) \in A - 1 _ { n } \otimes b ^ { ( \mu ) } \bigg | w ^ { ( \mu ) } , b ^ { ( \mu ) } \right\}
+$$
+
+is exactly that the vector $\phi \big ( \widetilde { f } ^ { ( \mu - 1 ) } ( \mathbf { x } ) \big )$ lies in the preimage of the convex set $A - 1 _ { n } \otimes b ^ { ( \mu ) }$ under the linear map $w ^ { ( \mu ) }$ , which is again a convex set. Secondly, observe that for the specific ReLU nonlinearity $\phi$ , if $C$ is an arbitrary convex set, then $\{ ( f ^ { ( \mu - 1 ) } ( \mathbf { \bar { x } } ) | \phi ( f ^ { ( \mu - 1 ) } ( \mathbf { x } ) ) \in C \}$ may be written as the disjoint union of at most $\bar { 2 } ^ { n H _ { \mu - 1 } }$ convex sets:
+
+$$
+\begin{array} { r l } & { \{ f ^ { ( \mu - 1 ) } ( \mathbf { x } ) | \phi ( f ^ { ( \mu - 1 ) } ( \mathbf { x } ) ) \in C \} } \\ & { = ( \phi ^ { - 1 } ( C ) \cap \{ t \in \mathbb { R } ^ { n H _ { \mu - 1 } } | t _ { i } \geq 0 \forall i \} ) \cup } \\ & { \underset { I \subseteq \{ 1 , \dots , n H _ { \mu - 1 } \} } { \bigcup } \{ t \in \mathbb { R } ^ { n H _ { \mu - 1 } } | t _ { I } < 0 , \exists y \in C \mathrm { ~ s . t . ~ } y _ { I ^ { c } } = t _ { I ^ { c } } , y _ { I } = 0 \} . } \end{array}
+$$
+
+Applying the assumed bound in the statement of the lemma to each of these sets, we obtain
+
+$$
+\begin{array} { r } { | \mathbb { P } \big ( \phi \big ( f ^ { ( \mu - 1 ) } ( \mathbf { x } ) \big ) \in C \big ) - \mathbb { P } \big ( \phi \big ( \widetilde { f } ^ { ( \mu - 1 ) } ( \mathbf { x } ) \big ) \in C \big ) | \leq 2 ^ { n H _ { \mu - 1 } } \varepsilon . } \end{array}
+$$
+
+Substituting this bound into the conditional probability (17) yields
+
+$$
+\vert \mathbb { P } ( f ^ { ( \mu ) } ( \mathbf { x } ) \in A ) - \mathbb { P } ( \widetilde { f } ^ { ( \mu ) } ( \mathbf { x } ) \in A ) \vert \le 2 ^ { n H _ { \mu - 1 } } \varepsilon .
+$$
+
+Since $A$ was an arbitrary convex set, the proof is complete.
+
+Proof of Lemma 4. Note that by independence of $\widetilde { g } _ { j } ^ { ( \mu - 1 ) } ( \mathbf { x } )$ from $\widetilde { w } _ { \bullet , j } ^ { ( \mu ) }$ we have that each $X _ { j }$ has mean zero and covariance $\Sigma _ { \otimes } = \Sigma \otimes \hat { C } _ { w } ^ { ( \mu ) } I$ where $\Sigma$ is the covariance matrix of $\widetilde { g } _ { j } ^ { ( \mu - 1 ) } ( \mathbf { x } )$ . By standard properties of the Kronecker product, the Schur decomposition of $\Sigma _ { \otimes }$ is $( Q \Lambda Q ^ { T } ) \otimes ( \hat { C } _ { w } ^ { ( \mu ) } I )$ where $Q \dot { \boldsymbol { \Lambda } } Q ^ { \dot { \boldsymbol { T } } }$ is the Schur decomposition of $\Sigma$ . Simple algebraic manipulation yields:
+
+$$
+\begin{array} { r l } { \mathfrak { z } \left[ \| Q _ { \otimes } \Lambda _ { \otimes } ^ { - 1 / 2 } Q _ { \otimes } ^ { T } ( \widetilde { g } _ { j } ^ { ( \mu - 1 ) } ( \mathbf { x } ) \otimes \widetilde { w } _ { \cdot , j } ^ { ( \mu ) } ) \| ^ { 3 } \right] = \mathbb { E } \left[ \| ( Q \Lambda ^ { - 1 / 2 } Q ^ { T } \widetilde { g } _ { j } ^ { ( \mu - 1 ) } ( \mathbf { x } ) ) \otimes ( ( \widehat { C } _ { w } ^ { ( \mu ) } ) ^ { - 1 / 2 } \widetilde { w } _ { \cdot , j } ^ { ( \mu ) } ) \| ^ { 3 } \right] } & { } \\ { = \mathbb { E } \left[ \| Q \Lambda ^ { - 1 / 2 } Q ^ { T } \widetilde { g } _ { j } ^ { ( \mu - 1 ) } ( \mathbf { x } ) \| ^ { 3 } \right] \mathbb { E } \left[ \| ( \widehat { C } _ { w } ^ { ( \mu ) } ) ^ { - 1 / 2 } \widetilde { w } _ { \cdot , j } ^ { ( \mu ) } \| ^ { 3 } \right] . } & { } \end{array}
+$$
+
+Notice that the random variable $( \hat { C } _ { w } ^ { ( \mu ) } ) ^ { - 1 / 2 } \widetilde { w } _ { \bullet , j } ^ { ( \mu ) }$ follows the $\mathbb { R } ^ { H _ { \mu } }$ -dimensional standard normal disetribution, and thus its squared norm follows the chi-squared distribution with $H _ { \mu }$ degrees of freedom, which is also known as the $\mathrm { G a m m a } ( H _ { \mu } / 2 , 1 / 2 )$ distribution. Exponentiating to the power of $3 / 2$ and taking the expectation, we obtain:
+
+$$
+\mathbb { E } \left[ \| ( \hat { C } _ { w } ^ { ( \mu ) } ) ^ { - 1 / 2 } \widetilde { w } _ { \bullet , j } ^ { ( \mu ) } \| ^ { 3 } \right] = 2 ^ { 3 / 2 } \frac { \Gamma \big ( ( H _ { \mu } + 3 ) / 2 \big ) } { \Gamma ( H _ { \mu } / 2 ) } .
+$$
+
+Finally, $\| Q \Lambda ^ { - 1 / 2 } Q ^ { T } \widetilde { g } _ { j } ^ { ( \mu - 1 ) } ( { \bf x } ) \| ^ { 3 } \le \| \widetilde { g } _ { j } ^ { ( \mu - 1 ) } ( { \bf x } ) \| ^ { 3 } / \lambda _ { \operatorname* { m i n } } ^ { 3 / 2 }$ where $\lambda _ { \operatorname* { m i n } }$ is the smallest value on the diagonal of $\Lambda$ e. If the activation $\phi$ e does not increase the norm of the input vector (as is the case for rectified linear), we have $\| \widetilde { g } _ { j } ^ { ( \mu - 1 ) } ( \mathbf { x } ) \| ^ { 3 } \leq \| Z _ { j } ^ { ( \mu - 1 ) } ( \mathbf { x } ) \| ^ { 3 }$ almost surely, where $Z _ { j } ^ { ( \mu - 1 ) } ( { \bf x } )$ follows the known $\mathbf { n }$ e-dimensional normal distribution with mean zero and covariance matrix whose Schur decomposition will be denoted as $U \Psi U ^ { T }$ . Using standard Gaussian identities, we can write
+
+$$
+\begin{array} { r } { \mathbb { E } \left[ \Vert Z _ { j } ^ { ( \mu - 1 ) } ( \mathbf { x } ) \Vert ^ { 3 } \right] = \mathbb { E } \left[ \Vert U \Psi ^ { 1 / 2 } \varepsilon \Vert ^ { 3 } \right] = \mathbb { E } \left[ \Vert \Psi ^ { 1 / 2 } \varepsilon \Vert ^ { 3 } \right] \leq 2 ^ { 3 / 2 } \psi _ { \operatorname* { m a x } } ^ { 3 / 2 } \frac { \Gamma ( ( n + 3 ) / 2 ) } { \Gamma ( n / 2 ) } , } \end{array}
+$$
+
+where $\varepsilon \sim \mathcal { N } ( 0 , I _ { n } )$ and $\psi _ { \mathrm { { m a x } } }$ is the highest entry on the diagonal of $\Psi$ . Putting it all together, we arrive at the desired upper bound $C _ { H _ { \mu } , n }$
+
+$$
+\mathbb { E } \left[ \| Q _ { \otimes } \Lambda _ { \otimes } ^ { - 1 / 2 } Q _ { \otimes } ^ { T } X _ { j } \| ^ { 3 } \right] \leq \left( 4 \frac { \psi _ { \mathrm { m a x } } } { \lambda _ { \mathrm { m i n } } } \right) ^ { 3 / 2 } \frac { \Gamma ( ( H _ { \mu } + 3 ) / 2 ) } { \Gamma ( H _ { \mu } / 2 ) } \frac { \Gamma ( ( n + 3 ) / 2 ) } { \Gamma ( n / 2 ) } .
+$$
+
+Because $\psi _ { \mathrm { m a x } }$ and $\lambda _ { \operatorname* { m i n } }$ are derived from the distribution of the limiting variable $\widetilde { g } _ { j } ^ { ( \mu - 1 ) } ( \mathbf { x } ) \ =$ $\phi ( Z _ { j } ^ { ( \mu - 1 ) } ( \mathbf { x } ) )$ , which only depends on $\mu$ , the bound only depends on $H _ { \mu }$ and $n$ e as desired. Further, noting that $\Gamma ( ( x + 3 ) / 2 ) / \Gamma ( x / 2 ) = \mathcal { O } ( x ^ { 2 } )$ , we have that $C _ { H _ { \mu } , n } = \mathcal { O } ( H _ { \mu } ^ { 2 } n ^ { 2 } )$ , as required.
+
+Proof of Proposition $^ { l }$ . We first apply Lemma 3 to the assumed inequality
+
+$$
+\begin{array} { r } { d \big ( f ^ { ( \mu - 1 ) } ( \mathbf { x } ) , Z ^ { ( \mu - 1 ) } ( \mathbf { x } ) \big ) \leq 2 ^ { - ( ( D + 1 ) - ( \mu - 1 ) ) - n \sum _ { k = \mu - 1 } ^ { D } H _ { k } } \varepsilon , } \end{array}
+$$
+
+to obtain
+
+$$
+\begin{array} { r } { d \big ( f ^ { ( \mu ) } ( \mathbf { x } ) , \widetilde { f } ^ { ( \mu ) } ( \mathbf { x } ) \big ) \leq 2 ^ { - ( ( D + 1 ) - ( \mu - 1 ) ) - n \sum _ { k = \mu } ^ { D } H _ { k } } \varepsilon . } \end{array}
+$$
+
+We apply Lemma 2 so that for $H _ { D }$ sufficiently large, we have
+
+$$
+\begin{array} { r } { d \bigl ( \widetilde { f } ^ { ( \mu ) } ( \mathbf { x } ) , Z ^ { ( \mu ) } ( \mathbf { x } ) \bigr ) \leq 2 ^ { - ( ( D + 1 ) - ( \mu - 1 ) ) - n \sum _ { k = \mu } ^ { D } H _ { k } } \varepsilon . } \end{array}
+$$
+
+Applying the triangle inequality then yields
+
+$$
+\begin{array} { r } { d \bigl ( f ^ { ( \mu ) } ( \mathbf { x } ) , Z ^ { ( \mu ) } ( \mathbf { x } ) \bigr ) \leq 2 ^ { - ( ( D + 1 ) - \mu ) - n \sum _ { k = \mu } ^ { D } H _ { k } } \varepsilon , } \end{array}
+$$
+
+as required.
+
+Proof of Proposition 2. The idea of the proof is to chain Proposition 1 together across the layers of the network. We fix $\varepsilon > 0$ , and apply Proposition 1 to each layer of the network, yielding the following set of implications for $H _ { D }$ sufficiently large:
+
+$$
+\begin{array} { r l } & { \qquad d ( f ^ { ( \mu - 1 ) } ( \mathbf { x } ) , Z ^ { ( \mu - 1 ) } ( \mathbf { x } ) ) \leq 2 ^ { - ( ( D + 1 ) - ( \mu - 1 ) ) - n \sum _ { k = \mu - 1 } ^ { D } H _ { k } } \varepsilon } \\ & { \qquad \implies d ( f ^ { ( \mu ) } ( \mathbf { x } ) , Z ^ { ( \mu ) } ( \mathbf { x } ) ) \leq 2 ^ { - ( ( D + 1 ) - \mu ) - n \sum _ { k = \mu } ^ { D } H _ { k } } \varepsilon , } \end{array}
+$$
+
+for $\mu \in \{ 2 , \ldots , D + 1 \}$ . Finally, note that from the definition of the network, the distribution of $f ^ { ( 1 ) } ( \mathbf { x } )$ is exactly multivariate normal with the required covariance structure, so that $d ( f ^ { ( 1 ) } ( { \bf x } ) , Z ^ { ( 1 ) } ( { \bf x } ) ) = 0$ , completing the proof. □
+
+Proof of Theorem $^ { l }$ . To prove that $( f ^ { ( D + 1 ) } ( x [ i ] ) ) _ { i = 1 } ^ { \infty }$ converges weakly to a Gaussian process with respect to the metric $\rho$ on $\mathbb { R } ^ { \mathbb { N } }$ given by:
+
+$$
+\rho ( v , v ^ { \prime } ) = \sum _ { i = 1 } ^ { \infty } 2 ^ { - i } \operatorname* { m i n } ( 1 , | v _ { i } - v _ { i } ^ { \prime } | ) \qquad \forall v , v ^ { \prime } \in \mathbb { R } ^ { \mathbb { N } } ,
+$$
+
+it is sufficient (Billingsley, 1999, p. 19) to prove weak convergence of the finite-dimensional marginals of the process to multivariate Gaussian random variables, with covariance matrix matching that specified by the kernel of the proposed Gaussian process.
+
+To this end, let $I$ be a finite subset of $\mathbb { N }$ , and consider the inputs $( x [ i ] ) _ { i \in I }$ . We may now apply Proposition 2 to obtain weak convergence of the joint distribution of the output variables of the network, $( f ^ { ( D + 1 ) } ( x [ i ] ) ) _ { i \in I }$ to a multivariate Gaussian with the correct covariance matrix. As the finite subset of inputs was arbitrary, we are done. □