Add files using upload-large-folder tool

parse/train/HygQBn0cYm/HygQBn0cYm.md

@@ -0,0 +1,421 @@
+# MODEL-PREDICTIVE POLICY LEARNING WITH UNCERTAINTY REGULARIZATION FOR DRIVING IN DENSE TRAFFIC
+
+Mikael Henaff ∗   
+Courant Institute, New York University   
+Microsoft Research, NYC   
+mbh305@nyu.edu   
+Alfredo Canziani ∗   
+Courant Institute, New York University   
+canziani@nyu.edu   
+Yann LeCun   
+Courant Institute, New York University   
+Facebook AI Research   
+yann@cs.nyu.edu
+
+# ABSTRACT
+
+Learning a policy using only observational data is challenging because the distribution of states it induces at execution time may differ from the distribution observed during training. We propose to train a policy by unrolling a learned model of the environment dynamics over multiple time steps while explicitly penalizing two costs: the original cost the policy seeks to optimize, and an uncertainty cost which represents its divergence from the states it is trained on. We measure this second cost by using the uncertainty of the dynamics model about its own predictions, using recent ideas from uncertainty estimation for deep networks. We evaluate our approach using a large-scale observational dataset of driving behavior recorded from traffic cameras, and show that we are able to learn effective driving policies from purely observational data, with no environment interaction.
+
+# 1 INTRODUCTION
+
+In recent years, model-free reinforcement learning methods using deep neural network controllers have proven effective on a wide range of tasks, from playing video or text-based games (Mnih et al., 2015; 2016; Narasimhan et al., 2015) to learning algorithms (Zaremba et al., 2015) and complex locomotion tasks (Lillicrap et al., 2015; Zhang et al., 2015). However, these methods often require a large number of interactions with the environment in order to learn. While this is not a problem if the environment is simulated, it can limit the application of these methods in realistic environments where interactions with the environment are slow, expensive or potentially dangerous. Building a simulator where the agent can safely try out policies without facing real consequences can mitigate this problem, but requires human engineering effort which increases with the complexity of the environment being modeled.
+
+Model-based reinforcement learning approaches try to learn a model of the environment dynamics, and then use this model to plan actions or train a parameterized policy. A common setting is where an agent alternates between collecting experience by executing actions using its current policy or dynamics model, and then using these experiences to improve its dynamics model. This approach has been shown empirically to significantly reduce the required number of environment interactions needed to obtain an effective policy or planner (Atkeson & Santamaria, 1997; Deisenroth & Rasmussen, 2011; Nagabandi et al., 2017; Chua et al., 2018).
+
+Despite these improvements in sample complexity, there exist settings where even a single poor action executed by an agent in a real environment can have consequences which are not acceptable. At the same time, with data collection becoming increasingly inexpensive, there are many settings where observational data of an environment is abundant.
+
+This suggests a need for algorithms which can learn policies primarily from observational data, which can then perform well in a real environment. Autonomous driving is an example of such a setting: on one hand, trajectories of human drivers can be easily collected using traffic cameras (Halkias & Colyar, 2006), resulting in an abundance of observational data; on the other hand, learning through interaction with the real environment is not a viable solution.
+
+However, learning policies from purely observational data is challenging because the data may only cover a small region of the space over which it is defined. If the observational data consists of stateaction pairs produced by an expert, one option is to use imitation learning (Pomerleau, 1991). However, this is well-known to suffer from a mismatch between the states seen at training and execution time (Ross & Bagnell, 2010). Another option is to learn a dynamics model from observational data, and then use it to train a policy (Nguyen & Widrow, 1989). However, the dynamics model may make arbitrary predictions outside the domain it was trained on, which may wrongly be associated with low cost (or high reward) as shown in Figure 1. The policy network may then exploit these errors in the dynamics model and produce actions which lead to wrongly optimistic states. In the interactive setting, this problem is naturally self-correcting, since states where the model predictions are wrongly optimistic will be more likely to be experienced, and thus will correct the dynamics model. However, the problem persists if the dataset of environment interactions which the model is trained on is fixed.
+
+![](images/66900dcd89593d494cbbea6b299375836408ab008987bd278fe1456262fa1063.jpg)  
+Figure 1: Different models fitted on training points which cover a limited region the function’s domain. Models make arbitrary predictions outside of this region.
+
+In this work, we propose to train a policy while explicitly penalizing the mismatch between the distribution of trajectories it induces and the one reflected in the training data. We use a learned dynamics model which is unrolled for multiple time steps, and train a policy network to minimize a differentiable cost over this rolled-out trajectory. This cost contains two terms: a policy cost which represents the objective the policy seeks to optimize, and an uncertainty cost which represents its divergence from the states it is trained on. We measure this second cost by using the uncertainty of the dynamics model about its own predictions, calculated using dropout. We apply our approach in the context of learning policies to drive an autonomous car in dense traffic, using a large-scale dataset of real-world driving trajectories which we also adapt into an environment for testing learned policies 1. We show that model-based control using this additional uncertainty regularizer substantially outperforms unregularized control, and enables learning good driving policies using only observational data with no environment interaction or additional labeling by an expert. We also show how to effectively leverage an action-conditional stochastic forward model using a modified posterior distribution, which encourages the model to maintain sensitivity to input actions.
+
+# 2 MODEL-PREDICTIVE POLICY LEARNING WITH UNCERTAINTY REGULARIZATION
+
+We assume we are given a dataset of observational data which consists of state-action pairs $\mathcal { D } =$ $\{ ( s _ { t } , a _ { t } ) \} _ { t }$ . We first describe our general approach, which consists of two steps: learning an actionconditional dynamics model using the collected observational data, and then using this model to train a fast, feedforward policy network which minimizes both a policy cost and an uncertainty cost.
+
+# 2.1 ACTION-CONDITIONAL FORWARD MODEL
+
+In this work, we consider recent approaches for stochastic prediction based on Variational Autoencoders (Kingma & Welling, 2013; Babaeizadeh et al., 2017; Denton & Fergus, 2018). The stochastic model $f _ { \theta } ( s _ { 1 : t } , a _ { t } , z _ { t } )$ takes as input a sequence of observed or previously predicted states $s _ { 1 : t }$ , an action $a _ { t }$ , and a latent variable $z _ { t }$ which represents the information about the next state $s _ { t + 1 }$ which is not a deterministic function of the input. During training, latent variables are sampled from a distribution whose parameters are output by a posterior network $q _ { \phi } ( s _ { 1 : t } , s _ { t + 1 } )$ conditioned on the past inputs and true targets. This network is trained jointly with the rest of the model using the reparameterization trick, and a term is included in the loss to minimize the KL divergence between the posterior distribution and a fixed prior $p ( z )$ , which in our case is an isotropic Gaussian.
+
+The per-sample loss used for training the stochastic model is given by:
+
+$$
+\mathcal { L } ( \theta , \phi ; s _ { 1 : t } , s _ { t + 1 } , a _ { t } ) = \| s _ { t + 1 } - f _ { \theta } ( s _ { 1 : t } , a _ { t } , z _ { t } ) \| _ { 2 } ^ { 2 } + \beta D _ { K L } ( q _ { \phi } ( z | s _ { 1 : t } , s _ { t + 1 } ) | | p ( z ) )
+$$
+
+After training, different future predictions for a given sequence of frames can be generated by sampling different latent variables from the prior distribution.
+
+Recent models for stochastic video prediction (Babaeizadeh et al., 2017; Denton & Fergus, 2018) do not use their model for planning or training a policy network, and parameterize the posterior distribution over latent variables using a diagonal Gaussian. In our case, we are training an actionconditional video prediction model which we will later use to train a policy. This leads to an additional requirement: it is important for the prediction model to accurately respond to input actions, and not use the latent variables to encode factors of variation in the outputs which are due to the actions. To this end we propose to use a mixture of two Gaussians, with one component fixed to the prior, as our posterior distribution:
+
+$$
+\begin{array} { l } { \displaystyle ( \mu _ { \phi } , \sigma _ { \phi } ) = q _ { \phi } ( s _ { 1 : t } , s _ { t + 1 } ) } \\ { \displaystyle u \qquad \sim \mathcal { B } ( p _ { u } ) } \\ { z _ { t } \qquad \sim ( 1 - u ) \cdot \mathcal { N } ( \mu _ { \phi } , \sigma _ { \phi } ) + u \cdot p ( z ) } \end{array}
+$$
+
+This can be seen as applying a form of global dropout to the latent variables at training time 2, and forces the prediction model to extract as much information as possible from the input states and actions by making the latent variable independent of the output with some probability. In our experiments we will refer to this parameterization as $z$ -dropout.
+
+# 2.2 TRAINING A POLICY NETWORK WITH UNCERTAINTY MINIMIZATION
+
+Once the forward model is trained, we use it to train a parameterized policy network $\pi _ { \psi }$ , which we assume to be stochastic. We first sample an initial state sequence $s _ { 1 : t }$ from the training set, unroll the forward model over $T$ time steps, and backpropagate gradients of a differentiable objective function with respect to the parameters of the policy network (shown in Figure 2). During this process the weights of the forward model are fixed, and only the weights of the policy network are optimized. This objective function contains two terms: a policy cost $C$ , which reflects the underlying objective the policy is trying to learn, and an uncertainty cost $U$ , which reflects how close the predicted state induced by the policy network is to the manifold which the data $\mathcal { D }$ is drawn from.
+
+Training the policy using a stochastic forward model involves solving the following problem, where latent variables are sampled from the prior and input into the forward model at every time step:
+
+$$
+\underset { \psi } { \arg \operatorname* { m i n } } \ \Big [ \sum _ { i = 1 } ^ { T } C \big ( \hat { s } _ { t + i } \big ) + \lambda U \big ( \hat { s } _ { t + i } \big ) \Big ] , \ \mathrm { s u c h \ t h a t : } \ \left\{ \begin{array} { l l } { z _ { t + i } \sim p ( z ) } \\ { \hat { a } _ { t + i } \sim \pi _ { \psi } \big ( \hat { s } _ { t + i - 1 } \big ) } \\ { \hat { s } _ { t + i } = f \big ( \hat { s } _ { t + i - 1 } , \hat { a } _ { t + i } , z _ { t + i } \big ) } \end{array} \right.
+$$
+
+The uncertainty cost $U$ is applied to states predicted by the forward model, and could reflect any measure of their likelihood under the distribution the training data is drawn from. We propose here a general form based on the uncertainty of the dynamics model, which is calculated using dropout. Intuitively, if the dynamics model is given a state-action pair from the same distribution as $\mathcal { D }$ (which it was trained on), it will have low uncertainty about its prediction. If it is given a state-action pair which is outside this distribution, it will have high uncertainty.
+
+![](images/6357d5ef90cb7996387b32d648965ec64dd37b3674481c8612030be088ae9c3b.jpg)  
+Figure 2: Training the policy network using the stochastic forward model. Gradients with respect to costs associated with predicted states are passed through the unrolled forward model into a policy network.
+
+Dropout (Hinton et al., 2012; Srivastava et al., 2014) is a regularization technique which consists of randomly setting hidden units in a neural network to zero with some probability. The work of (Gal & Ghahramani, 2016) showed that estimates of the neural network’s uncertainty for a given input can be obtained by calculating the covariance of its outputs taken over multiple dropout masks. We note that this uncertainty estimate is the composition of differentiable functions: each of the models induced by applying a different dropout mask is differentiable, as is the covariance operator. Furthermore, we can summarize the covariance matrix by taking its trace (which is equal to the sum of its eigenvalues, or equivalently the sum of the variances of the outputs across each dimension), which is also a differentiable operation. This provides a scalar estimate of uncertainty which is differentiable with respect to the input.
+
+More precisely, let $f _ { \theta _ { 1 } } , . . . , f _ { \theta _ { K } }$ denote our prediction model with $K$ different dropout masks applied to its hidden units (this can also be viewed as changing its weights). We define our scalar measure of uncertainty $U$ as follows:
+
+$$
+\begin{array} { r } { U ( \hat { s } _ { t + 1 } ) = \mathrm { t r } \Big [ \mathrm { C o v } [ \{ f _ { \theta _ { k } } ( s _ { 1 : t } , a _ { t } , z _ { t } ) \} _ { k = 1 } ^ { K } ] \Big ] } \\ { = \displaystyle \sum _ { j = 1 } ^ { d } \mathrm { V a r } ( \{ f _ { \theta _ { k } } ( s _ { 1 : t } , a _ { t } , z _ { t } ) _ { j } \} _ { k = 1 } ^ { K } ) } \end{array}
+$$
+
+where $d$ is the dimensionality of the output. Minimizing this quantity with respect to actions encourages the policy network to produce actions which, when plugged into the forward model, will produce predictions which the forward model is confident about 3.
+
+A simple way to define $U$ given an initial sequence of states $s _ { 1 : t }$ from $\mathcal { D }$ would be to set $U ( \bar { s } _ { t + k } ) = \| \bar { s } _ { t + k } - s _ { t + k } \| _ { 2 }$ , which would encourage the policy network to output actions which lead to a similar trajectory as the one observed in the dataset. This leads to a set of states which the model is presumably confident about, but may not be a trajectory which also satisfies the policy cost $C$ unless the dataset $\mathcal { D }$ consists of expert trajectories. If this is the case, setting $\begin{array} { r } { C ( \hat { s } _ { t + i } ) \stackrel { \cdot } { = } U ( \hat { s } _ { t + i } ) = \frac { 1 } { 2 } \| \hat { s } _ { t + k } - s _ { t + k } \| _ { 2 } } \end{array}$ gives a model-based imitation learning objective which simultaneously optimizes the policy cost and the uncertainty cost. The problem then becomes:
+
+![](images/3e260f40c6a4c84942a40d5dd999f186d464f2d0f946284f7b3684ff0939e3c6.jpg)  
+Figure 3: Training the policy network using the differentiable uncertainty cost, calculated using dropout.
+
+$$
+\underset { \psi } { \operatorname { a r g m i n } } \ : \Big [ \sum _ { i = 1 } ^ { T } \lVert \hat { s } _ { t + i } - s _ { t + i } \rVert _ { 2 } \Big ] , \ \mathrm { s u c h \ t h a t : } \ \left\{ \begin{array} { l l } { z _ { t + i } \sim q _ { \phi } ( z | s _ { 1 : t } , s _ { t + 1 } ) } \\ { \hat { a } _ { t + i } \sim \pi _ { \psi } ( \hat { s } _ { t + i - 1 } ) } \\ { \hat { s } _ { t + i } = f \big ( \hat { s } _ { t + i - 1 } , \hat { a } _ { t + i } , z _ { t + i } \big ) } \end{array} \right.
+$$
+
+We call the first approach MPUR , for Model-Predictive Policy with Uncertainty Regularization, and the second MPER , for Model-Predictive Policy with Expert Regularization. A key feature of both approaches is that we optimize the objective over $T$ time steps, which is made possible by our learned dynamics model. This means that the actions will receive gradients from multiple time steps ahead, which will penalize actions which lead to large divergences from the training manifold further into the future, even if they only cause a small divergence at the next time step.
+
+# 2.3 RELATIONSHIP TO BAYESIAN NEURAL NETWORKS
+
+Our MPUR approach can be viewed as training a Bayesian neural network (BNN) (Neal, 1995) with latent variables using variational inference (Jordan et al., 1999; Kingma & Welling, 2013). The distribution over model predictions for $s _ { t + 1 }$ is given by:
+
+$$
+p ( s _ { t + 1 } | s _ { 1 : t } , a , \mathcal { D } ) = \int p ( s _ { t + 1 } | f _ { \theta } ( s _ { 1 : t } , a , z ) ) p ( \theta , z | \mathcal { D } ) d \theta d z
+$$
+
+The distribution $p ( \boldsymbol { \theta } , z | \mathcal { D } )$ reflects the posterior over model weights and latent variables given the data, and is intractable to evaluate. We instead approximate it with the variational distribution $q$ parameterized by $\eta = \{ \phi , \theta ^ { * } \}$ :
+
+$$
+q _ { \eta } ( z , \theta ) = q _ { \phi } ( z | s _ { 1 : t } , s _ { t + 1 } ) \cdot q _ { \theta ^ { * } } ( \theta )
+$$
+
+Here $q _ { \phi }$ represents a distribution over latent variables represented using a posterior network with parameters $\phi$ , which could be a diagonal Gaussian or the mixture distribution described in Section 2.1. The distribution $q _ { \theta ^ { * } }$ is the dropout approximating distribution over forward model parameters described in (Gal & Ghahramani, 2016), a mixture of two Gaussians with one mean fixed at zero. We show in Appendix B that training the stochastic forward model with dropout by minimizing the loss function in Equation 1 is approximately minimizing the Kullback-Leibler divergence between this approximate posterior and the true posterior.
+
+![](images/0833ea6dfd7ff54ba29b481a6391b4c17288cd005136498d0e60f382ecd07aa4.jpg)  
+Figure 4: Preprocessing pipeline for the NGSIM-I80 data set. Orange arrows show same vehicles across stages. Blue arrows show corresponding extracted context state. (a) Snapshots from two of the seven cameras. (b) View point transformation, car localisation and tracking. (c) Context states are extracted from rectangular regions surrounding each vehicle. (d) Five examples of context states $i _ { t }$ extracted at the previous stage.
+
+Once the forward model is trained, for a given input we can obtain an approximate distribution over outputs $p ( \widehat { s } _ { t + 1 } | s _ { 1 : t } , a )$ induced by the approximate posterior by sampling different latent variables and dropout masks. We now show that the covariance of the outputs $\hat { s } _ { t + 1 }$ can be decomposed into a sum of two covariance matrices which represent the aleatoric and epistemic uncertainty, using a similar approach as (Depeweg et al., 2018). Using the conditional covariance formula we can write:
+
+$$
+\operatorname { c o v } ( \hat { s } _ { t + 1 } | s _ { 1 : t } , a ) = \operatorname { c o v } _ { \boldsymbol { \theta } } ( \mathbb { E } _ { z } [ \hat { s } _ { t + 1 } | s _ { 1 : t } , a , \boldsymbol { \theta } ] ) + \mathbb { E } _ { \boldsymbol { \theta } } [ \operatorname { c o v } _ { z } ( \hat { s } _ { t + 1 } | s _ { 1 : t } , a , \boldsymbol { \theta } ) ]
+$$
+
+The first term is the covariance of the random vector $\mathbb { E } _ { z } \big [ \hat { s } _ { t + 1 } | s _ { 1 : t } , a , \theta \big ]$ when $\theta \sim q _ { \theta ^ { * } } ( \theta )$ . This term ignores any contribution to the variance from $z$ and only considers the effect of $\theta$ . As such it represents the epistemic uncertainty. The second term represents the covariance of the predictions obtained by sampling different latent variables $z \sim p ( z )$ averaged over different dropout masks, and ignores any contribution to the variance from $\theta$ . As such it represents the aleatoric uncertainty. Our uncertainty penalty explicitly penalizes the trace of the first matrix where the expectation over $z$ is approximated by a single sample from the prior. Note also that the covariance matrix corresponding to the aleatoric uncertainty will change depending on the inputs. This allows our approach to handle heteroscedastic environments, where the aleatoric uncertainty will vary for different inputs.
+
+# 3 DATASET AND PLANNING ENVIRONMENT
+
+We apply our approach to learn driving policies using a large-scale dataset of driving videos taken from traffic cameras. The Next Generation Simulation program’s Interstate 80 (NGSIM I-80) dataset (Halkias & Colyar, 2006) consists of 45 minutes of recordings from traffic cameras mounted over a stretch of highway. The driver behavior is complex and includes sudden accelerations, lane changes and merges which are difficult to predict; as such the dataset has high environment (or aleatoric) uncertainty. After recording, a viewpoint transformation is applied to rectify the perspective, and vehicles are identified and tracked throughout the video. This yields a total 5596 car trajectories, which we split into training $( 8 0 \% )$ , validation $( 1 0 \% )$ and testing sets $( 1 0 \% )$ . In all, the dataset contains approximately 2 million transitions.
+
+We then applied additional preprocessing to obtain a state and action representation $\left( { { s _ { t } } , { a _ { t } } } \right)$ for each car at each time step, suitable for learning an action-conditional predictive model. Our state representation $s _ { t }$ consists of two components: an image $i _ { t }$ representing the neighborhood of the car, and a vector $u _ { t }$ representing its current position and velocity. The images $i _ { t }$ are centered around the ego car and encode both the lane emplacements and the locations of other cars. Each image has 3 channels: the first (red) encodes the lane markings, the second (green) encodes the locations of neighboring cars, which are represented as rectangles reflecting the dimensions of each car, and the third channel (blue) represents the ego car, also scaled to the correct dimensions. This is summarized in Figure 4. The action $a _ { t }$ at a given time step consists of a 2-dimensional vector representing the acceleration/braking of the car and its change in steering angle. We also define two cost functions which together make up the policy cost: a proximity cost which reflects how close the ego car is to neighboring cars, and a lane cost which reflects how much the ego car overlaps with lane markings. These are represented as a cost vector at each timestep, $c _ { t } = ( C _ { \mathrm { p r o x i m i t y } } ( s _ { t } ) , C _ { \mathrm { l a n e } } ( s _ { t } ) )$ . Full details can be found in Appendix A.
+
+We also adapted this dataset to be used as an environment to evaluate learned policies, with the same interface as OpenAI Gym (Brockman et al., 2016). Choosing a policy for neighboring cars is challenging due to a cold-start problem: to accurately evaluate a learned policy, the other cars would need to follow human-like policies which would realistically react to the controlled car, which are not available. We take the approach of letting all the other cars in the environment follow their trajectories from the dataset, while a single car is controlled by the policy we seek to evaluate. This approach avoids hand-designing a policy for the neighboring cars which would likely not reflect the diverse nature of human driving. The limitation is that the neighboring cars do not react to the controlled car, which likely makes the problem more difficult as they do not try to avoid collisions.
+
+# 4 RELATED WORK
+
+A number of authors have explored the use of learned, action-conditional forward models which are then used for planning, starting with classic works in the 90’s (Nguyen & Widrow, 1990; Schmidhuber, 1990; Jordan & Rumelhart, 1992), and more recently in the context of video games (Oh et al., 2015; Pascanu et al., 2017; Weber et al., 2017), robotics and continous control (Finn et al., 2016; Agrawal et al., 2016; Nagabandi et al., 2017; Srinivas et al., 2018). Our approach to learning policies by backpropagating through a learned forward model is related to the early work of (Nguyen & Widrow, 1989) in the deterministic case, and the SVG framework of (Heess et al., 2015) in the stochastic case. However, neither of these approaches incorporates a term penalizing the uncertainty of the forward model when training the policy network.
+
+The works of (McAllister & Rasmussen, 2016; Chua et al., 2018) also used model uncertainty estimates calculated using dropout in the context of model-based reinforcement learning, but used them for sampling trajectories during the forward prediction step. Namely, they applied different dropout masks to simulate different state trajectories which reflect the distribution over plausible models, which were then averaged to produce a cost estimate used to select an action.
+
+Our model uncertainty penalty is related to the cost used in (Kahn et al., 2017), who used dropout and model ensembling to compute uncertainty estimates for a binary action-conditional collision detector for a flying drone. These estimates were then used to select actions out of a predefined set which yielded a good tradeoff between speed, predicted chance of collision and uncertainty about the prediction. In our work, we apply uncertainty estimates to the predicted high-dimensional states of a forward model at every time step, summarize them into a scalar, and backpropagate gradients through the unrolled forward model to then train a policy network by gradient descent.
+
+The work of (Depeweg et al., 2018) also proposed adding an uncertainty penalty when training paramaterized policies, but did so in the context of BNNs trained using $\alpha$ -divergences applied in low-dimensional settings, whereas we use variational autoencoders combined with dropout for high-dimensional video prediction. $\alpha$ -BNNs can yield better uncertainty estimates than variational inference-based methods, which can underestimate model uncertainty by fitting to a local mode of the exact posterior (Depeweg et al., 2016; Li & Gal, 2017). However, they also require computing multiple samples from the distribution over model weights when training the forward model, which increases memory requirements and limits scalability to high-dimensional settings such as the ones we consider here.
+
+The problem of covariate shift when executing a policy learned from observational data has been well-recognized in imitation learning (Pomerleau, 1991; Ross & Bagnell, 2010). The work of (Ross et al., 2011) proposed a method to efficiently use expert feedback (if available) to correct this shift, which has also been applied in the context of autonomous driving (Zhang & Cho, 2016). Our approach also addresses covariate shift, but does so without querying an expert.
+
+![](images/220312232871dbe4d44fa3cb521828a37bee59f094777d267224ee0e33c3e117.jpg)  
+Figure 5: Video prediction results using a deterministic and stochastic model over 200 time steps (images are subsampled across time). Two different future predictions are generated by the stochastic model by sampling two different sequences of latent variables. The deterministic model averages over possible futures, producing blurred predictions.
+
+Our MPER approach is related to the work of (Englert et al., 2013), who also performed imitation learning at the level of trajectories rather than individual actions. They did so in low-dimensional settings using Gaussian Processes, whereas our method uses an unrolled neural network representing the environment dynamics which can be applied to high-dimensional state representations. The work of (Baram et al., 2017) also used a neural network dynamics model in the context of imitation learning, but did so in the interactive setting to minimize a loss produced by a discriminator network.
+
+Several works have used deep learning models for autonomous driving, either to learn policies through imitation learning (Pomerleau, 1991; LeCun et al., 2006; Bojarski et al., 2016; Pan et al., 2017) or for modeling vehicle dynamics (Williams et al., 2017). These works focused on lane following or avoiding static obstacles in visually rich environments and did not consider settings with dense moving traffic. The work of (Sadigh et al., 2016) developed a model of the interactions between the two drivers which was then used to plan actions in simple settings, using symbolic state representations. In our work, we consider the problem of learning driving policies in dense traffic, using high-dimensional state representations which reflect the neighborhood of the ego car.
+
+# 5 EXPERIMENTS
+
+We now report experimental results. We designed a deterministic and stochastic forward model to model the state and action representations described in Section 3, using convolutional layers to process the images $i _ { t }$ and fully-connected layers to process the vectors $u _ { t }$ and actions $a _ { t }$ . All model details can be found in Appendix C and training details can be found in Appendix D. Code and additional video results for the model predictions and learned policies can be found at the following URL: https://sites.google.com/view/model-predictive-driving/home.
+
+# 5.1 PREDICTION RESULTS
+
+We first generated predictions using both deterministic and stochastic forward models, shown in Figure 5. The deterministic model produces predictions which become increasingly blurry, while the stochastic model produces predictions which stay sharp far into the future. By sampling different sequences of latent variables, different future scenarios are generated. Note that the two sequences generated by the stochastic model are different from the ground truth future which occurs in the dataset. This is normal as the future observed in the dataset is only one of many possible ones. Additional video generations can be viewed at the URL.
+
+<table><tr><td>Method Model</td><td>Mean Distance</td><td>Success Rate (%)</td></tr><tr><td colspan="2">Human</td><td>209.4</td><td>100.0</td></tr><tr><td colspan="2">No action</td><td>87.3</td><td>16.2</td></tr><tr><td colspan="2">1-step IL</td><td>73.8± 7.9</td><td>7.3 ± 4.1</td></tr><tr><td colspan="2">SVG stochastic VG deterministic</td><td>17.1 ± 4.3 11.9 ± 4.2</td><td>0.0±0.0 0.0± 0.0</td></tr><tr><td colspan="2">MPUR stochastic+z-dropout MPUR stochastic MPUR deterministic MPER stochastic MPER deterministic</td><td>171.2 ± 4.5 166.8 ± 2.4 162.4 ± 2.8 70.0 ± 8.0</td><td>74.8± 3.0 71.8 ± 1.0 69.1 ± 1.6 4.6 ± 2.1</td></tr></table>
+
+![](images/eb9db0f860e29a0604e6a7c01f10c559d8933c6f917bc1a3f1137a9c9dd14d01.jpg)
+
+(c)   
+Figure 6: a) Performance different methods, measured in success rate and distance travelled. Including a cost term penalizing the dynamics model’s uncertainty is essential for good performance. Using the modified posterior distribution $z$ -dropout) improves performance when using the stochastic forward model. b) Training policies by performing longer rollouts through the environment dynamics model also significantly improves performance. c) Summary of compared methods.   
+
+<table><tr><td rowspan=1 colspan=1>Human</td><td rowspan=1 colspan=1>The human trajectories observed in the testing set,which are all collision-free.</td></tr><tr><td rowspan=1 colspan=1>No action</td><td rowspan=1 colspan=1>A policy which outputs an action of zero, maintaining constant speed and direction.</td></tr><tr><td rowspan=1 colspan=1>1-step IL</td><td rowspan=1 colspan=1> A policy network trained with single-step imitation learning.</td></tr><tr><td rowspan=1 colspan=1>SVG</td><td rowspan=1 colspan=1>A policy network trained with stochastic value gradients. This is the same setupas (Heess et al.,2O15),with the difference that the agent does not interact with theenvironment and learns froma fixed observational dataset.</td></tr><tr><td rowspan=1 colspan=1>VG</td><td rowspan=1 colspan=1>A policy trained with value gradients, using the deterministic forward model. Thisis similar to SVG, but does not involve latent variables.</td></tr><tr><td rowspan=1 colspan=1>MPUR</td><td rowspan=1 colspan=1>A policy trained with MPUR,using a deterministic or stochastic model.A costterm is included to penalize the uncertainty of the dynamics model.</td></tr><tr><td rowspan=1 colspan=1>MPER</td><td rowspan=1 colspan=1>A policy trained with MPER , using a deterministic or stochastic model. The policyis trained to match expert trajectories from the training set.</td></tr></table>
+
+# 5.2 POLICY EVALUATION RESULTS
+
+We evaluated policies using two measures: whether the controlled car reaches the end of the road segment without colliding into another car or driving off the road, and the distance travelled before the episode ends. Policies which collide quickly will travel shorter distances.
+
+We compared our approach against several baselines which can also learn from observational data, which are described in Figure 6c. Table 6a compares performance for the different methods, optimized over different rollout lengths. The 1-step imitation learner, SVG and VG all perform poorly, and do not beat the simple baseline of performing no action. Both MPUR and MPER significantly outperform the other methods. Videos of the learned policies for both MPER and MPUR driving in
+
+![](images/fcf640d0fa7b44801e0c0c30f649eb112d4341cd1b345f23a091384d3dd11c10.jpg)
+
+Figure 7: Trajectories for MPUR , MPER and a single-step imitation learner policies over the stretch of highway. The single-step imitation learner policy often veers across lanes, whereas the other policies stay within. These policies also change their speed to avoid collisions (see URL).   
+
+<table><tr><td>Method</td><td>Mean Distance (m)</td><td>Success Rate (%)</td><td>Total Predicted Cost</td><td>U</td></tr><tr><td>VG</td><td>14.9</td><td>0.0</td><td>0.05</td><td>1081.2</td></tr><tr><td>MPUR</td><td>168.8</td><td>73.5</td><td>0.13</td><td>0.4</td></tr></table>
+
+Table 1: Policy and uncertainty costs with and without uncertainty regularization. The policy trained with unregularized VG exploits errors in the forward model to produce actions which yield low predicted cost but high uncertainty. Including the uncertainty cost yields higher predicted cost, but better performance when the policy is executed in the environment.
+
+the environment can be found at the URL. The policies learn effective behaviors such as braking, accelerating and turning to avoid other cars. Figure 7 shows trajectories on the map for different methods. We see that the single-step imitation learner produces divergent trajectories which turn into other lanes, whereas the MPUR and MPER methods show trajectories which primarily stay within their lanes.
+
+MPUR becomes equivalent to VG in the deterministic setting if we remove the uncertainty penalty, and the large difference in performance shows that including this penalty is essential. Table 1 shows the average predicted policy cost and uncertainty cost of the two methods. VG produces much lower predicted policy cost, yet very high uncertainty cost. This indicates that the actions the policy produces induce a distribution over states which the forward model is highly uncertain about. The policy trained with MPUR produces higher policy cost estimates, but lower uncertainty cost, and performs much better when executed in the environment.
+
+The stochastic model trained with a standard Gaussian posterior yields limited improvement over the deterministic model. However, the stochastic model trained with the $z$ -dropout parameterization yields a significant improvement. Comparisons of action-conditional predictions using both models can be seen at the URL. The standard model is less responsive to input actions than the model trained with $z$ -dropout, which likely accounts for their difference in performance. We hypothesize that the standard model uses its latent variables to encode factors of variation in the output which are in fact due to the actions. Using $z$ -dropout discourages this since information in the output cannot be encoded in the latent variables the times they are sampled from the prior, and the loss can better be lowered by predicting the outputs from the actions instead. Please see Appendix E for additional experiments and discussion of this phenomenon.
+
+Figure 6b shows the performance of MPUR and MPER for different rollout lengths. All methods see their performance improve dramatically as we increase the rollout length, which encourages the distribution of states the policy induces and the training distribution to match over longer time horizons. We also see that the stochastic model with $z$ -dropout outperforms the standard stochastic model as well as the deterministic model over most rollout lengths.
+
+# 6 CONCLUSION
+
+In this work, we proposed a general approach for learning policies from purely observational data. The key elements are: i) a learned stochastic dynamics model, which is used to optimize a policy cost over multiple time steps, ii) an uncertainty term which penalizes the divergence of the trajectories induced by the policy from the manifold it was trained on, and iii) a modified posterior distribution which keeps the stochastic model responsive to input actions. We have applied this approach to a large observational dataset of real-world traffic recordings, and shown it can effectively learn policies for navigating in dense traffic, which outperform other approaches which learn from observational data. However, there is still a sizeable gap between the performance of our learned policies and human performance. We release both our dataset and environment, and encourage further research in this area to help narrow this gap. We also believe this provides a useful setting for evaluating generative models in terms of their ability to produce good policies. Finally, our approach is general and could potentially be applied to many other settings where interactions with the environment are expensive or unfeasible, but observational data is plentiful.
+
+# REFERENCES
+
+Pulkit Agrawal, Ashvin Nair, Pieter Abbeel, Jitendra Malik, and Sergey Levine. Learning to poke by poking: Experiential learning of intuitive physics. CoRR, abs/1606.07419, 2016. URL http: //arxiv.org/abs/1606.07419.   
+C. G. Atkeson and J. C. Santamaria. A comparison of direct and model-based reinforcement learning. In Proceedings of International Conference on Robotics and Automation, volume 4, pp. 3557–3564 vol.4, April 1997. doi: 10.1109/ROBOT.1997.606886.   
+Mohammad Babaeizadeh, Chelsea Finn, Dumitru Erhan, Roy H. Campbell, and Sergey Levine. Stochastic variational video prediction. CoRR, abs/1710.11252, 2017. URL http://arxiv. org/abs/1710.11252.   
+Nir Baram, Oron Anschel, Itai Caspi, and Shie Mannor. End-to-end differentiable adversarial imitation learning. In ICML, 2017.   
+Mariusz Bojarski, Davide Del Testa, Daniel Dworakowski, Bernhard Firner, Beat Flepp, Prasoon Goyal, Lawrence D. Jackel, Mathew Monfort, Urs Muller, Jiakai Zhang, Xin Zhang, Jake Zhao, and Karol Zieba. End to end learning for self-driving cars. CoRR, abs/1604.07316, 2016.   
+Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym, 2016.   
+Kurtland Chua, Roberto Calandra, Rowan McAllister, and Sergey Levine. Deep reinforcement learning in a handful of trials using probabilistic dynamics models. CoRR, abs/1805.12114, 2018. URL http://arxiv.org/abs/1805.12114.   
+Marc Peter Deisenroth and Carl Edward Rasmussen. Pilco: A model-based and data-efficient approach to policy search. In In Proceedings of the International Conference on Machine Learning, 2011.   
+Emily Denton and Rob Fergus. Stochastic video generation with a learned prior. CoRR, abs/1802.07687, 2018. URL http://arxiv.org/abs/1802.07687.   
+Stefan Depeweg, Jose Miguel Hern ´ andez-Lobato, Finale Doshi-Velez, and Steffen Udluft. Learn- ´ ing and policy search in stochastic dynamical systems with bayesian neural networks. CoRR, abs/1605.07127, 2016. URL http://arxiv.org/abs/1605.07127.   
+Stefan Depeweg, Jose-Miguel Hernandez-Lobato, Finale Doshi-Velez, and Steffen Udluft. Decomposition of uncertainty in Bayesian deep learning for efficient and risk-sensitive learning. 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. 1184–1193, Stockholmsmssan, Stockholm Sweden, 10–15 Jul 2018. PMLR. URL http://proceedings. mlr.press/v80/depeweg18a.html.   
+P. Englert, A. Paraschos, J. Peters, and M. P. Deisenroth. Model-based imitation learning by probabilistic trajectory matching. In 2013 IEEE International Conference on Robotics and Automation, pp. 1922–1927, May 2013. doi: 10.1109/ICRA.2013.6630832.   
+Chelsea Finn, Ian J. Goodfellow, and Sergey Levine. Unsupervised learning for physical interaction through video prediction. CoRR, abs/1605.07157, 2016. URL http://arxiv.org/abs/ 1605.07157.
+
+Yarin Gal and Zoubin Ghahramani. Dropout as a bayesian approximation: Representing model uncertainty in deep learning. In Maria Florina Balcan and Kilian Q. Weinberger (eds.), Proceedings of The 33rd International Conference on Machine Learning, volume 48 of Proceedings of Machine Learning Research, pp. 1050–1059, New York, New York, USA, 20–22 Jun 2016. PMLR. URL http://proceedings.mlr.press/v48/gal16.html.
+
+John Halkias and James Colyar. NGSIM interstate 80 freeway dataset. US Federal Highway Administration, FHWA-HRT-06-137, Washington, DC, USA, 2006.
+
+Nicolas Heess, Gregory Wayne, David Silver, Tim Lillicrap, Tom Erez, and Yuval Tassa. Learning continuous control policies by stochastic value gradients. In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, and R. Garnett (eds.), Advances in Neural Information Processing Systems 28, pp. 2944–2952. Curran Associates, Inc., 2015.
+
+Geoffrey E. Hinton, Nitish Srivastava, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Improving neural networks by preventing co-adaptation of feature detectors. CoRR, abs/1207.0580, 2012. URL http://arxiv.org/abs/1207.0580.
+
+Michael I. Jordan and David E. Rumelhart. Forward models: Supervised learning with a distal teacher. Cognitive Science, 16(3):307 – 354, 1992. ISSN 0364-0213. doi: http://dx.doi.org/ 10.1016/0364-0213(92)90036-T. URL http://www.sciencedirect.com/science/ article/pii/036402139290036T.
+
+Michael I. Jordan, Zoubin Ghahramani, Tommi S. Jaakkola, and Lawrence K. Saul. An introduction to variational methods for graphical models. Mach. Learn., 37(2):183–233, November 1999. ISSN 0885-6125. doi: 10.1023/A:1007665907178. URL https://doi.org/10.1023/A: 1007665907178.
+
+Gregory Kahn, Adam Villaflor, Vitchyr Pong, Pieter Abbeel, and Sergey Levine. Uncertainty-aware reinforcement learning for collision avoidance. 02 2017.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2014. URL http://arxiv.org/abs/1412.6980.
+
+Diederik P. Kingma and Max Welling. Auto-encoding variational bayes. CoRR, abs/1312.6114, 2013. URL http://dblp.uni-trier.de/db/journals/corr/corr1312.html# KingmaW13.
+
+Yann LeCun, Urs Muller, Jan Ben, Eric Cosatto, and Beat Flepp. Off-road obstacle avoidance through end-to-end learning. In Y. Weiss, B. Scholkopf, ¨ and J. C. Platt (eds.), Advances in Neural Information Processing Systems 18, pp. 739–746. MIT Press, 2006. URL http://papers.nips.cc/paper/ 2847-off-road-obstacle-avoidance-through-end-to-end-learning. pdf.
+
+Yingzhen Li and Yarin Gal. Dropout inference in Bayesian neural networks with alpha-divergences. In Doina Precup and Yee Whye Teh (eds.), Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pp. 2052–2061, International Convention Centre, Sydney, Australia, 06–11 Aug 2017. PMLR. URL http:// proceedings.mlr.press/v70/li17a.html.
+
+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. CoRR, abs/1509.02971, 2015.
+
+Rowan McAllister and Carl E. Rasmussen. Improving pilco with bayesian neural network dynamics models. 2016.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin Riedmiller, Andreas K. Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, February 2015. ISSN 0028-0836. doi: 10.1038/nature14236. URL http://dx.doi.org/10.1038/nature14236.
+
+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. CoRR, abs/1602.01783, 2016.
+
+Anusha Nagabandi, Gregory Kahn, Ronald S. Fearing, and Sergey Levine. Neural network dynamics for model-based deep reinforcement learning with model-free fine-tuning. CoRR, abs/1708.02596, 2017. URL http://arxiv.org/abs/1708.02596.
+
+Karthik Narasimhan, Tejas D. Kulkarni, and Regina Barzilay. Language understanding for textbased games using deep reinforcement learning. CoRR, abs/1506.08941, 2015. URL http: //arxiv.org/abs/1506.08941.
+
+Radford M. Neal. Bayesian Learning for Neural Networks. PhD thesis, Toronto, Ont., Canada, Canada, 1995. AAINN02676.
+
+Nguyen and Widrow. The truck backer-upper: an example of self-learning in neural networks. In International 1989 Joint Conference on Neural Networks, pp. 357–363 vol.2, 1989. doi: 10.1109/ IJCNN.1989.118723.
+
+Derrick Nguyen and Bernard Widrow. Neural networks for control. chapter The Truck Backerupper: An Example of Self-learning in Neural Networks, pp. 287–299. MIT Press, Cambridge, MA, USA, 1990. ISBN 0-262-13261-3. URL http://dl.acm.org/citation.cfm?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ 104204.104216.
+
+Junhyuk Oh, Xiaoxiao Guo, Honglak Lee, Richard L. Lewis, and Satinder P. Singh. Actionconditional video prediction using deep networks in atari games. CoRR, abs/1507.08750, 2015. URL http://arxiv.org/abs/1507.08750.
+
+Yunpeng Pan, Ching-An Cheng, Kamil Saigol, Keuntaek Lee, Xinyan Yan, Evangelos Theodorou, and Byron Boots. Agile off-road autonomous driving using end-to-end deep imitation learning. CoRR, abs/1709.07174, 2017. URL http://arxiv.org/abs/1709.07174.
+
+Razvan Pascanu, Yujia Li, Oriol Vinyals, Nicolas Heess, Lars Buesing, Sebastien Racani ´ ere, \` David P. Reichert, Theophane Weber, Daan Wierstra, and Peter Battaglia. Learning model-based planning from scratch. CoRR, abs/1707.06170, 2017.
+
+Dean A. Pomerleau. Efficient training of artificial neural networks for autonomous navigation. Neural Computation, 3:97, 1991.
+
+Stephane Ross and J. Andrew Bagnell. Efficient reductions for imitation learning. In ´ AISTATS, 2010.
+
+Stphane Ross, Geoffrey J. Gordon, and Drew Bagnell. A reduction of imitation learning and structured prediction to no-regret online learning. In Geoffrey J. Gordon, David B. Dunson, and Miroslav Dudk (eds.), AISTATS, volume 15 of JMLR Proceedings, pp. 627–635. JMLR.org, 2011.
+
+Dorsa Sadigh, Shankar Sastry, Sanjit A. Seshia, and Anca D. Dragan. Planning for autonomous cars that leverage effects on human actions, 06 2016.
+
+Jurgen Schmidhuber. An on-line algorithm for dynamic reinforcement learning and planning in reactive environments. In Proceedings of the International Joint Conference on Neural Networks (IJCNN), 1990.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. CoRR, abs/1707.06347, 2017. URL http://arxiv.org/abs/ 1707.06347.
+
+Aravind Srinivas, Allan Jabri, Pieter Abbeel, Sergey Levine, and Chelsea Finn. Universal planning networks. CoRR, abs/1804.00645, 2018. URL http://arxiv.org/abs/1804.00645.
+
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15:1929–1958, 2014. URL http://jmlr.org/papers/v15/ srivastava14a.html.
+
+Theophane Weber, Sebastien Racani ´ ere, David P. Reichert, Lars Buesing, Arthur Guez, \` Danilo Jimenez Rezende, Adria Puigdom \` enech Badia, Oriol Vinyals, Nicolas Heess, Yujia Li, \` Razvan Pascanu, Peter Battaglia, David Silver, and Daan Wierstra. Imagination-augmented agents for deep reinforcement learning. CoRR, abs/1707.06203, 2017.
+
+G. Williams, N. Wagener, B. Goldfain, P. Drews, J. M. Rehg, B. Boots, and E. A. Theodorou. Information theoretic mpc for model-based reinforcement learning. In 2017 IEEE International Conference on Robotics and Automation (ICRA), pp. 1714–1721, May 2017. doi: 10.1109/ICRA. 2017.7989202.
+
+Wojciech Zaremba, Tomas Mikolov, Armand Joulin, and Rob Fergus. Learning simple algorithms from examples. CoRR, abs/1511.07275, 2015. URL http://arxiv.org/abs/1511. 07275.
+
+Fangyi Zhang, Jurgen Leitner, Michael Milford, Ben Upcroft, and Peter I. Corke. Towards vision- ¨ based deep reinforcement learning for robotic motion control. CoRR, abs/1511.03791, 2015. URL http://arxiv.org/abs/1511.03791.
+
+Jiakai Zhang and Kyunghyun Cho. Query-efficient imitation learning for end-to-end autonomous driving. CoRR, abs/1605.06450, 2016. URL http://arxiv.org/abs/1605.06450.
+
+# A DATASET AND PLANNING ENVIRONMENT
+
+To begin with, we describe the details and preparation of the dataset and planning environment which we used, which are summarized in Figure 4. The Next Generation Simulation program’s Interstate 80 (NGSIM I-80) dataset (Halkias & Colyar, 2006) consists of 45 minutes of recordings made of a stretch of highway in the San Francisco Bay Area by cameras mounted on a 30-story building overlooking the highway. The recorded area includes six freeway lanes (including a high-occupancy vehicle lane) and an onramp. The driver behavior is complex and includes sudden accelerations, lane changes and merges which are difficult to predict; as such the dataset has high aleatoric uncertainty. There are three time segments, each of 15 minutes, taken at different times of day which capture the transition between uncongested and congested peak period conditions. After recording, a viewpoint transformation is applied to rectify the perspective, and vehicles are identified and tracked throughout the video; additionally, their size is inferred. This yields a total 5596 car trajectories, represented as sequences of coordinates $\{ x _ { t } , y _ { t } \}$ . We split these trajectories into training $( 8 0 \% )$ , validation $( 1 0 \% )$ ) and testing sets $( 1 0 \% )$ ).
+
+We then applied additional preprocessing to obtain suitable representations for learning a predictive model. Specifically, we extracted the following: i) a state representation for each car at each time step $s _ { t }$ , which encodes the necessary information to choose an action to take, ii) an action $a _ { t }$ which represents the action of the driver, and iii) a cost $c _ { t }$ , which associates a quality measure to each state. We describe each of these below.
+
+State representation: Our state representation consists of two components: an image representing the neighborhood of the car, and a vector representing its current position and velocity. For the images, we rendered images centered around each car which encoded both the lane emplacements and the locations of other cars. Each image has 3 channels: the first (red) encodes the lane markings, the second (green) encodes the locations of neighboring cars, which are represented as rectangles reflecting the dimensions of each car, and the third channel (blue) represents the ego car, also scaled to the correct dimensions. All images have dimensions $3 \times 1 1 7 \times 2 4$ , and are denoted by $i _ { t }$ . 4 Two examples are shown in Figure 8. We also computed vectors $\boldsymbol { u } _ { t } = ( p _ { t } , \Delta p _ { t } )$ , where $p _ { t } = ( x _ { t } , y _ { t } )$ is the position at time $t$ and $\Delta p _ { t } = ( x _ { t + 1 } - x _ { t } , y _ { t + 1 } - y _ { t } )$ is the velocity.
+
+![](images/bee19c8b218eddbeee1ff1f1a4087c9e6def191a4daee9f78308adb982266444.jpg)  
+Figure 8: Image state representations and proximity cost masks for cars going at different speeds. The higher the speed, the longer the safety distance required to maintain low cost.
+
+Action representation: Each action vector $a _ { t }$ consists of two components: an acceleration (which can be positive or negative) which reflects the change in speed, and a change in angle. The acceleration at a given time step is computed by taking the difference between two consecutive speeds, while the change in angle is computed by projecting the change in speed along its orthogonal direction:
+
+$$
+\begin{array} { r l } & { \Delta \mathrm { s p e e d } = \| \Delta p _ { t + 1 } \| _ { 2 } - \| \Delta p _ { t } \| _ { 2 } } \\ & { \Delta \mathrm { a n g l e } = ( \Delta p _ { t + 1 } - \Delta p _ { t } ) ^ { \top } ( \Delta p _ { t } ) _ { \bot } / \| \Delta p _ { t } \| _ { 2 } } \\ & { \qquad a _ { t } = ( \Delta \mathrm { s p e e d } , \Delta \mathrm { a n g l e } ) } \end{array}
+$$
+
+Cost: Our cost function has two terms: a proximity cost and a lane cost. The proximity cost reflects how close the ego car is to neighboring cars, and is computed using a mask in pixel space whose width is equal to the width of a lane and whose height depends on the speed of the car. Two examples are shown in Figure 8. This mask is pointwise multiplied with the green channel, and the maximum value is taken to produce a scalar cost. The lane cost uses a similar mask fixed to the size of the car, and is similarly multiplied with the red channel, thus measuring the car’s overlap with the lane. Both of these operations are differentiable so that we can backpropagate gradients with respect to these costs through images predicted by a forward model.
+
+This preprocessing yields a set of state-action pairs $\left( { { s _ { t } } , { a _ { t } } } \right)$ (with $s _ { t } = ( i _ { t } , u _ { t } ) ,$ ) for each car, which constitute the dataset we used for training our prediction model. We then use the cost function to optimize action sequences at planning time, using different methods which we describe in Section 2.2.
+
+We now describe how we adapted this dataset to be used as an environment to evaluate planning methods. Building an environment for evaluating policies for autonomous driving is not obvious as it suffers from a cold-start problem. Precisely measuring the performance of a given driving policy would require it to be evaluated in an environment where all other cars follow policies which accurately reflect human behavior. This involves reacting appropriately both to other cars in the environment as well as the car being controlled by the policy being evaluated. However, constructing such an environment is not possible as it would require us to already have access to a policy which drives as humans do, which in some sense is our goal in the first place. One could hand-code a driving policy to control the other cars in the environment, however is it not clear how to do so in a way which accurately reflects the diverse and often unpredictable nature of human driving.
+
+![](images/1c1a45684895ba69c95602eaa9568fe4f3d968d96cebd56688a7015d9ac8614a.jpg)  
+Figure 9: NGSIM planning environment.
+
+We adopt a different approach where we let all other cars in the environment follow their trajectories in the dataset, while controlling one car with the policy we seek to evaluate. The trajectory of the controlled car is updated as a function of the actions output by the policy, while the trajectories of the other cars remain fixed. If the controlled car collides with another car, this is recorded and the episode ends. This approach has the advantage that all other cars in the environment maintain behavior which is close to human-like. The one difference with true human behavior is that the other cars do not react to the car being controlled or try to avoid it, which may cause crashes which would not occur in real life. The driving task is thus possibly made more challenging than in a true environment, which we believe is preferable to using a hand-coded policy. The interface is set up the same way as environments in OpenAI Gym (Brockman et al., 2016), and can be accessed with a few lines of Python code, as shown in Figure 9.
+
+# B BAYESIAN NEURAL NETWORK FORMULATION DETAILS
+
+Our MPUR approach can be viewed as training a Bayesian neural network (BNN) (Neal, 1995) with latent variables using variational inference (Jordan et al., 1999; Kingma & Welling, 2013). The distribution over model predictions for $s _ { t + 1 }$ is given by:
+
+$$
+p ( s _ { t + 1 } | s _ { 1 : t } , a , \mathcal { D } ) = \int p ( s _ { t + 1 } | f _ { \theta } ( s _ { 1 : t } , a , z ) ) p ( \theta , z | \mathcal { D } ) d \theta d z
+$$
+
+The distribution $p ( \boldsymbol { \theta } , z | \mathcal { D } )$ reflects the posterior over model weights and latent variables given the data, and is intractable to evaluate. We instead approximate it with the variational distribution $q$ parameterized by $\eta$ :
+
+$$
+q _ { \eta } ( z , \theta ) = q _ { \phi } ( z | s _ { 1 : t } , s _ { t + 1 } ) \cdot q _ { \theta ^ { * } } ( \theta )
+$$
+
+Here $q _ { \phi }$ represents a distribution over latent variables parameterized by $\phi$ , which could be a diagonal Gaussian or the mixture distribution described in Section 2.1. The distribution $q _ { \theta ^ { * } }$ is the dropout approximating distribution over model parameters described in (Gal & Ghahramani, 2016) (Section 3.2 of Supplement). This defines a mixture of two Gaussians with small variances over each row of each weight matrix in the forward model, with the mean of one Gaussian fixed at zero. The parameters of this distribution are the model weights, and samples can be drawn by applying different dropout masks. The parameters of the variational distribution are thus $\eta = \{ \bar { \theta } ^ { * } , \bar { \phi } \}$ , and can be optimized by maximizing the evidence lower bound, which is equivalent to minimizing the Kullback-Leibler divergence between the approximate posterior and true posterior:
+
+$$
+^ { \bullet } _ { E L B O } ( \theta ^ { \ast } , \phi ; s _ { 1 : t } , s _ { t + 1 } , a ) = \int \log p ( s _ { t + 1 } | f _ { \theta } ( s _ { 1 : t } , a , z ) ) q _ { \eta } ( \theta , z ) d \theta d z - D _ { K L } ( q _ { \eta } ( \theta , z ) | | p _ { 0 } ( \theta , z ) ) \mathrm { d } \eta .
+$$
+
+Here $p _ { 0 } ( z , \theta ) = p _ { 0 } ( z ) \cdot p _ { 0 } ( \theta )$ represents a prior over latent variables and model parameters. By applying the chain rule for KL divergences together with the fact that $z$ and $\theta$ are independent, we obtain:
+
+$$
+\begin{array} { r l } & { D _ { K L } ( q _ { \eta } ( \theta , z ) | | p _ { 0 } ( \theta , z ) ) = D _ { K L } ( q _ { \phi } ( z | s _ { 1 : t } , s _ { t + 1 } ) \cdot q _ { \theta ^ { * } } ( \theta ) | | p _ { 0 } ( z ) \cdot p _ { 0 } ( \theta ) ) } \\ & { \qquad = D _ { K L } ( q _ { \phi } ( z | s _ { 1 : t } , s _ { t + 1 } ) | | p _ { 0 } ( z ) ) + D _ { K L } ( q _ { \theta ^ { * } } ( \theta | z ) | | p _ { 0 } ( \theta | z ) ) } \\ & { \qquad = D _ { K L } ( q _ { \phi } ( z | s _ { 1 : t } , s _ { t + 1 } ) | | p _ { 0 } ( z ) ) + D _ { K L } ( q _ { \theta ^ { * } } ( \theta ) | | p _ { 0 } ( \theta ) ) } \end{array}
+$$
+
+Setting both Gaussians in $p _ { 0 } ( \theta )$ to have zero mean, the second KL term becomes equivalent to scaled $\ell _ { 2 }$ regularization on the model parameters, and can be set arbitrarily small (Section 4.2 in Supplement of (Gal & Ghahramani, 2016)). Ignoring this term and approximating the integral in Equation 3 using a single sample, we obtain:
+
+$$
+\mathscr { L } _ { E L B O } ( \theta ^ { * } , \phi ; s _ { 1 : t } , s _ { t + 1 } , a ) \approx \log p ( s _ { t + 1 } | f _ { \bar { \theta } } ( s _ { 1 : t } , a , z ) ) - D _ { K L } ( q _ { \phi } ( z | s _ { 1 : t } , s _ { t + 1 } ) | | p _ { 0 } ( z ) )
+$$
+
+where $\bar { \theta } \sim q _ { \theta ^ { * } } ( \theta )$ and $z \sim q _ { \phi } ( s _ { 1 : t } , s _ { t + 1 } ) )$ . Assuming a diagonal Gaussian likelihood on the outputs with constant variance $1 / \beta$ , we can rewrite this as:
+
+$$
+\mathcal { L } _ { E L B O } ( \theta ^ { * } , \phi ; s _ { 1 : t } , s _ { t + 1 } , a ) \approx - \frac { 1 } { \beta } \cdot \Vert s _ { t + 1 } - f _ { \bar { \theta } } ( s _ { 1 : t } , a , z ) \Vert - D _ { K L } ( q _ { \phi } ( z | s _ { 1 : t } , s _ { t + 1 } ) | | p _ { 0 } ( z ) )
+$$
+
+Multiplying by $\beta$ does not change the maximum. We now see that maximizing this quantity is equivalent to minimizing our loss term in Equation 1, i.e. training a variational autoencoder with dropout.
+
+# C MODEL DETAILS
+
+The architecture of our forward model consists of four neural networks: a state encoder $f _ { \mathrm { e n c } }$ , an action encoder $f _ { \mathrm { a c t } }$ , a decoder $f _ { \mathrm { d e c } }$ , and the posterior network $f _ { \phi }$ . At every time step, the state encoder takes as input the concatenation of 20 previous states, each of which consists of a context image $i _ { t }$ and a 4-dimensional vector $u _ { t }$ encoding the car’s position and velocity. The images $i _ { t - 2 0 } , . . . , i _ { t }$ are run through a 3-layer convolutional network with 64-128-256 feature maps, and the vectors $u _ { t - 2 0 } , . . . , u _ { t }$ are run through a 2-layer fully connected network with 256 hidden units, whose final layers contain the same number of hidden units as the number of elements in the output of the convolutional network (we will call this number $n _ { H }$ ). The posterior network takes the same input as the encoder network, as well as the the ground truth state $s _ { t + 1 }$ , and maps them to a distribution over latent variables, from which one sample $z _ { t }$ is drawn. This is then passed through an expansion layer which maps it to a representation of size $n _ { H }$ . The action encoder, which is a 2-layer fully-connected network, takes as input a 2-dimensional action $a _ { t }$ encoding the car’s acceleration and change in steering angle, and also maps it to a representation of size $n _ { H }$ . The representations of the input states, latent variable, and action, which are all now the same size, are combined via addition. The result is then run through a deconvolutional network with 256-128-64 feature maps, which produces a prediction for the next image $i _ { t + 1 }$ , and a 2-layer fully-connected network (with 256 hidden units) which produces a prediction for the next state vector $u _ { t + 1 }$ . These are illustrated in Figure C.
+
+The specific updates of the stochastic forward model are given by:
+
+$$
+\begin{array} { r l } & { ( \mu _ { \phi } , \sigma _ { \phi } ) } \\ & { \epsilon } \\ & { z _ { t } } \\ & { \hat { s } _ { t + 1 } = ( \widetilde { i } _ { t + 1 } , \widetilde { u } _ { t + 1 } ) = f _ { \theta } ( s _ { 1 : t } , s _ { t + 1 } , z _ { t } ) } \\ & { - \mathcal { N } ( 0 , I ) } \end{array}
+$$
+
+The per-sample loss is given by:
+
+$$
+\ell ( s _ { 1 : t } , s _ { t + 1 } ) = \| \widetilde { i } _ { t } - i _ { t } \| _ { 2 } ^ { 2 } + \| \widetilde { u } _ { t } - u _ { t } \| _ { 2 } ^ { 2 } + \beta D _ { K L } ( { \mathcal { N } } ( \mu _ { \phi } , \sigma _ { \phi } ) | | p ( z ) )
+$$
+
+![](images/5b7d40eb45db6bfec564eb2fc8fc722ea1aa4db744ab7e58dd286e57b212d76b.jpg)  
+Figure 10: Individual components of the prediction model.
+
+We also train a cost predictor which takes as input the states predicted by the forward model and produces a two-dimensional output (one output for the proximity cost, and one output for the lane cost). This consists of a 3-layer encoder followed by a two-layer fully connected network with sigmoid non-linearities as the end to constrain the values between 0 and 1.
+
+# D TRAINING DETAILS
+
+# D.1 FORWARD MODEL
+
+We trained our prediction model in deterministic mode $( p = 0 )$ ) for 200,000 updates, followed by another 200,000 updates in stochastic mode. We save the model after training in deterministic mode and treat it as a deterministic baseline. Our model was trained using Adam (Kingma & Ba, 2014) with learning rate 0.0001 and minibatches of size 64, unrolled for 20 time steps, and with dropout $( p _ { d r o p o u t } = 0 . 1 )$ ) at every layer, which was necessary for computing the epistemic uncertainty cost when training the policy network.
+
+# D.2 POLICY MODELS
+
+All cars are initialized at the beginning of the road segment with the initial speed they were driving at in the dataset, and then are controlled by the policy being measured. We only report performance for cars in the testing trajectories, which were not used when training the forward model or policy network.
+
+All policy networks have the same architecture: a 3-layer ConvNet with feature maps of size 64- 128-256 (which takes 20 consecutive frames as input), followed by 3 fully-connected layers with 256 hidden units each, with the last layer outputting the parameters of a 2D Gaussian distribution from which the action is sampled. All policy networks are trained with Adam with learning rate 0.0001. The MPER and MPUR policies are trained by backpropagation through the unrolled forward model using the reparamaterization trick (Kingma & Welling, 2013). The single-step imitation learner is trained to directly minimize the negative log-likelihood of the ground truth action in the dataset under the parameters output by the policy network. All MPUR policies use a weighting of $\lambda = 0 . 5$ for the uncertainty cost. Additionally, we detach gradients of predicted costs coming into the states, to prevent the policy from lowering the predicted cost (which is speed-dependent) by slowing down. We found that not doing this can result in the policy slowing excessively, and then attempting to speed up only when another car gets close. We repeat the policy training with 3 random seeds for each method.
+
+The policy cost which we minimize for VG, SVG and MPUR is given by:
+
+$$
+C = C _ { \mathrm { p r o x i m i t y } } + 0 . 2 \cdot C _ { \mathrm { l a n e } }
+$$
+
+where $C _ { \mathrm { p r o x i m i t y } }$ and $C _ { \mathrm { l a n e } }$ are the proximity and lane costs described in Section 3. This puts a higher priority on avoiding other cars while still encouraging the policy to stay within the lanes. MPUR additionally minimizes $U$ , the model uncertainty cost described in Section 2.2.
+
+When computing the uncertainty cost, to compensate for differences in baseline uncertainty across different rollout lengths, we normalize by the empirical mean and variance for every rollout length $t$ of the forward model over the training set, to obtain $\mu _ { U } ^ { t }$ and $\sigma _ { U } ^ { t }$ . We then define our uncertainty cost as follows:
+
+$$
+U ( \hat { s } _ { t + 1 } ) \gets \Big [ \frac { U ( \hat { s } _ { t + 1 } ) - \mu _ { U } ^ { t } } { \sigma _ { U } ^ { t } } \Big ] _ { + }
+$$
+
+If the uncertainty estimate is lower than the mean uncertainty estimate on the training set for this rollout length, this loss will be zero. These are cases where the model prediction is within normal uncertainty ranges. If the uncertainty estimate is higher, this loss exerts a pull to change the action so that the future state will be predicted with higher confidence by the forward model.
+
+# E ACTION SENSITIVITY EXPERIMENTS
+
+We found the lack of responsiveness of the stochastic forward model to be especially pronounced when it is given a sequence of latent variables inferred from the current training sequence by the posterior network, instead of a sequence of latent variables sampled from the prior (intuitively, using the inferred sequence corresponds to using the future from the dataset, while using a sampled sequence corresponds to a different future). One reason for this difference in responsiveness may be that in the first case, the latent variables are highly dependent whereas in the second they are independent. If action information is encoded in the latent variables, the effects on the output may partially cancel each other out when the latents are independent. However, when they are highly dependent, together they may explain away the effects of the actions input to the forward model.
+
+The table below shows the performance of MPUR policies learned using inferred and sampled latent variables. We see a large drop in performance when using the inferred latent variables. This is consistent with the videos at the URL, which show that the forward model is less sensitive to actions when the latent variables are sampled from the posterior instead of the prior. Note that the $z$ -dropout parameterization reduces this problem somewhat.
+
+<table><tr><td>Method</td><td>Sampling</td><td>Mean Distance</td><td>Success Rate</td></tr><tr><td>MPUR + z-dropout</td><td>2t~p(2)</td><td>168.2</td><td>72.1</td></tr><tr><td>MPUR</td><td>2t~p(2）</td><td>157.4</td><td>63.6</td></tr><tr><td>MPUR + z-dropout</td><td>2t ~ q(2|s1:t, St+1)</td><td>126.1</td><td>30.8</td></tr><tr><td>MPUR</td><td>2t~ q(z|s1:t,St+1）</td><td>86.0</td><td>19.2</td></tr></table>
+
+# F MODEL-FREE RESULTS
+
+Although the goal of this work is to learn policies with no environment interaction, for completeness we also report results of running Proximal Policy Optimization (PPO) (Schulman et al., 2017), a state-of-the-art model-free algorithm which learns through interacting with its environment. We used the OpenAI Baselines implementation (Brockman et al., 2016) with the same policy network architecture as for the other methods, and set the reward to be the negative policy cost defined in equation 9. We measure both final performance and cumulative regret, using the success rate as a reward. Cumulative regret is a measure often used in online learning which represents the difference between the agent’s accumulated reward and the accumulated reward which would have been obtained by following the optimal policy, which we take to be human performance here. Specifically, the regret at epoch $M$ is given by:
+
+$$
+\rho ( M ) = T \mathbb { E } [ R ^ { * } ] - \mathbb { E } [ \sum _ { m = 1 } ^ { M } \hat { R } _ { m } ]
+$$
+
+where $R ^ { * }$ represents the reward obtained by following the optimal policy and $R _ { m }$ is the reward obtained by following the policy at epoch $m$ . Unlike final performance, regret also reflects poor decisions made during the learning process.
+
+Results are shown in Figure 11. PPO obtains slightly higher final performance than MPUR, but also incurs higher regret as it executes poor policies in the environment during the early stages of learning. In contrast, MPUR learns through observational data and already has a good policy in place when it begins interacting with the environment.
+
+![](images/0aee0f342d62b81f11289c6ed60184f07bc3a441553c3103f7d45224272f4323.jpg)  
+Figure 11: Performance comparison for MPUR and PPO, in terms of a) cumulative regret and b) final performance
+
+<table><tr><td>Method</td><td>MeanDistance</td><td>Success Rate</td></tr><tr><td>MPUR + z-dropout</td><td>171.2 ± 4.5</td><td>74.8 ± 3.0</td></tr><tr><td>PPO</td><td>181.0 ± 6.7</td><td>77.8 ± 5.6</td></tr></table>

parse/train/S1GDXzb0b/S1GDXzb0b.md

@@ -0,0 +1,198 @@
+# MODEL-BASED IMITATION LEARNING FROM STATE TRAJECTORIES
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Imitation learning from demonstrations usually relies on learning a policy from trajectories of optimal states and actions. However, in real life expert demonstrations, often the action information is missing and only state trajectories are available. We present a model-based imitation learning method that can learn environment-specific optimal actions only from expert state trajectories. Our proposed method starts with a model-free reinforcement learning algorithm with a heuristic reward signal to sample environment dynamics, which is then used to train the state-transition probability. Subsequently, we learn the optimal actions from expert state trajectories by supervised learning, while back-propagating the error gradients through the modeled environment dynamics. Experimental evaluations show that our proposed method successfully achieves performance similar to (state, action) trajectory-based traditional imitation learning methods even in the absence of action information, with much fewer iterations compared to conventional model-free reinforcement learning methods. We also demonstrate that our method can learn to act from only video demonstrations of expert agent for simple games and can learn to achieve desired performance in less number of iterations.
+
+# 1 INTRODUCTION
+
+Reinforcement learning(RL) involves training an agent to learn a policy that accomplishes a certain task in an environment. The objective of reinforcement learning is to maximize the expected future reward Sutton & Barto (1998) from a guiding signal. Mnih et al. (2015) showed that neural networks can be used to approximate state-action value functions used by an agent to perform discrete control based on a guiding reward. This was demonstrated in Atari games where the score was used as the reward signal. Similarly, continuous control of robotics arm was achieved by Lillicrap et al. (2016) minimizing the distance between end-effector and target location. Following these, other methods such as Schulman et al. (2017; 2015) were proposed to improve the sample efficiency of modelfree algorithms with theoretical guarantees of policy improvement in each step. These algorithms assume that a guiding reward signal is available for the agent to learn optimal behavior for a certain task. However, in most cases of natural learning, such guiding signal is not present and learning is performed by imitating an expert behavior.
+
+Imitation learning involves copying the behavior of an expert agent to accomplish the desired task. In the conventional imitation learning setting, a set of expert trajectories providing states and optimal actions $\tau = \{ s _ { 0 } , { \pmb a } _ { 0 } , { \pmb s } _ { 1 } , { \pmb a } _ { 1 } , . . . , { \pmb s } _ { n } , { \pmb a } _ { n } \}$ performed by an expert agent $\pi _ { E }$ are available but the reward (or cost function), $r _ { E } ( s , a )$ used to achieve the expert behavior is not available. The goal is to learn a new policy $\pi$ , which imitates the expert behavior by maximizing the likelihood of given demonstration trajectories.
+
+A straightforward way for imitation learning is to direct learn the optimal action to perform given the current state as proposed by Pomerleau (1991); Duan et al. (2017). The policy $\pi$ can learn to imitate the expert behavior by maximizing likelihood of the condition distribution of action given states $p ( \pmb { a } | \pmb { s } )$ . This can be achieved by simply training a parameterized function (neural networks for instance) with state and action pairs from the expert trajectories. Since this involves end-to-end supervised learning, training is much more sample-efficient compared to reinforcement learning and overcomes inherent problems in model-free methods such as credit assignment(Sutton (1984)). However, since behavior cloning learns optimal action from a single state value only, it is unaware of the future state distribution the current action will produce. Thus, errors are compounded in the future states leading to undesired agent behavior as shown by Ross et al. (2011); Ross & Bagnell (2010). Therefore, numerous training samples are required for behavior cloning to reduce errors in action prediction required for satisfactory imitation learning.
+
+The second approach to imitation learning involves setting up exploration in a Markov Decision Process(MDP) setting. The goal then is to recover a reward signal that best explains the expert trajectories. $\mathrm { N g }$ & Russell (2000) first introduced Inverse Reinforcement Learning(IRL), where the goal is to find a reward signal $\hat { r }$ from the trajectories such that the expert is uniquely optimal. After computing this estimated reward signal, usually, a model-free reinforcement learning performed to obtain the desired policy imitating the expert behavior by maximizing the expected discounted reward $\begin{array} { r } { \mathbb { E } _ { \pi } \big ( \sum _ { t } \gamma ^ { t } \hat { r } \big ( s _ { t } , \dot { a } _ { t } \big ) \big ) } \end{array}$ . While this alleviates the problem of compounding errors as in behavior cloning, Ziebart et al. (2008) showed that estimating a unique reward function from state and action trajectories is an ill-posed problem.
+
+Following the success of Generative Adversarial Networks(GANs) (Goodfellow et al. (2014)) in various fields of machine learning, adversarial learning has also been shown incorporated in the imitation learning framework. The recent work on Generative Adversarial Imitation Leaning or GAIL by Ho & Ermon (2016) showed that model-free reinforcement learning using the discriminator as a cost function can learn to imitate the expert agent with much less number of demonstrated trajectories compared to behavior cloning. Following the success of GAIL, there have extensions by Baram et al. (2017) to model-based generative imitation learning using a differentiable dynamics model of the environment. Robust imitation policy strategies using a combination of variational autoencoders (Kingma & Ba (2015); Rezende et al. (2014)) and GAIL has also been proposed by Wang et al. (2017).
+
+The previous works assume that the expert trajectories consist of both action and state values from the optimal agent. However, optimal actions are usually not available in real-world imitation learning. For example, we often learn tasks like skipping, jump rope, gymnastics, etc. just by watching other expert humans perform the task. In this case, the optimal expert trajectories only consist of visual input, in other words, the consecutive states of the expert human with no action information. We learn to jump rope by trying to reproduce actions that result in state trajectories similar to the state trajectories observed from the expert. This requires exploring the environment in a structured fashion to learn the dynamics of the rope (for jump rope) which then enables executing optimal actions to imitate the expert behavior. The recent work of Liu et al. (2017) presents learning from observations only with focus to transferring skills learned from source domain to an unseen target domain, using rewards obtained by feature tracking for model-free reinforcement learning.
+
+Inspired by the above method of learning in humans, we present a principled way of learning to imitate an expert from state information only, with no action information available. We first learn a distribution of the next state from the current state trajectory, used to estimate a heuristic reward signal enabling model-free exploration. The state, action and next states information from modelfree exploration is used to learn a dynamics model of the environment. For the case of learning in humans, this is similar to performing actions for replicating the witnessed expert state trajectories, which in turn gives information about the dynamics of the environment. Once this forward model is learned, we try to find the action that maximizes the likelihood of next state. Since the forward model gives a function approximation for the environment dynamics, we can back propagate errors through it to perform model-based policy update by end to end supervised learning. We demonstrate that our proposed network can reach, with fewer iterations, the level close to an expert agent behavior (which is a pre-trained actor network or manually provided by humans), and compare it with reinforcement learning using a hand-crafted reward or a heuristics reward that is based on prediction error of next state learned from the optimal state trajectories of the expert.
+
+# 1.1 NOTATIONS
+
+We summarize the notations used in the paper in this section. Consider a Markov Decision Process (MDP) denoted as $( S , A , P , r , \rho _ { 0 } , \gamma )$ , where $S$ is the finite set of states, $A$ is the set of possible actions, $P : S \times A \to S$ is the transition probability distribution and $r : S \times A \to \mathbb { R }$ be the reward signal from state and actions, $\rho _ { 0 }  \mathcal { R }$ is the initial state distribution and $\gamma \in ( 0 , 1 )$ is the discount factor. Let $\pi : S \times A \to ( 0 , 1 )$ be the policy that gives the conditional distribution of actions given current state, $p ( \pmb { a } | \pmb { s } )$ and $R ( \pi ) = \mathbb { E } _ { \pi } [ \sum _ { t } \gamma ^ { t } r _ { t } ( s _ { t } , { \pmb a } _ { t } ) ]$ is the discounted reward associated with the policy. We consider expert trajectories consisting of only optimal state distribution without any action information, $\tau _ { E } = \{ s _ { 0 } , s _ { 1 } , . . . , s _ { n } \}$ . The trajectories sampled from model-free exploration is denoted as, $\tau _ { R L } = \{ s _ { 0 } , { a _ { 0 } } , { s _ { 1 } } , { a _ { 1 } } , . . . , { s _ { n } } , { a _ { n } } \}$ . We use the terms dynamic model, state-transition probability and forward model interchangeably in the paper. $f _ { E } ( \pmb { s } _ { t } , \pmb { a } _ { t } )$ denotes the non-differentiable forward model of the environment and $f ( \pmb { s } _ { t } , \pmb { a } _ { t } )$ denotes the differentiable version which is learned during the proposed training procedure. $\pi _ { m f }$ denotes the model-free policy and $\pi _ { m b }$ denotes the model-based policy network.
+
+# 2 PROPOSED METHOD
+
+While most previous works use trajectories containing both state and action information to infer a policy that imitates the expert behavior, our problem statement is to imitate an expert from optimal state trajectories only. This setting is common in many natural scenarios where only state information is available. For example, humans learning to swim by seeing videos or observing other experts swimmers, have access to the sensory stream of information containing states only. The optimal actions are obtained by trying to replicate the state trajectories in the real environment via exploration. In this work, we learn a time series predictor of next state given the current state. Subsequently, we estimate a heuristic reward signal at each step, based on the difference of predicted next state by the time series model and the actual next state taken by the policy network to learn a model-free policy with exploration. However, such heuristic methods suffer from the disadvantages of slow modelfree training to reach satisfactory policy and provide no guarantees on convergence. Therefore we resort to model-based policy learning that learns a differentiable model of the environment dynamics used to learn policy by directly supervised learning. The proposed algorithm alternates between dynamic model parameters and policy parameters update using gradient propagation through the differentiable dynamics model. We formalize this setup in the following sections.
+
+# 2.1 MODEL-FREE POLICY LEARNING VIA REWARD ESTIMATION
+
+Following the work in Inverse Reinforcement Learning(IRL), it is possible to frame the imitation learning problem in the MDP framework. The imitation learning problem then reduces to finding a uniquely optimal reward signal that maximizes the likelihood of the observed demonstration trajectories. However, finding a uniquely optimal reward function, even with optimal trajectories containing both state and action information, is an ill-posed problem. The ill-posed nature of optimal reward estimation is further accentuated in the absence of action information in expert trajectories. As such, many solutions for parameterized families of reward estimation models maximizing the likelihood of only expert state trajectories might be sub-optimal to learn the desired task.
+
+For model-free policy learning, we use a heuristic reward estimated by the error in next state prediction at each step. We make an assumption that estimating a locally optimal reward maximizing the likelihood of next step predicting, is intuitively globally optimal for learning the desired task. A straight-forward method to obtain such heuristic reward signal from the trajectories, $\tau _ { s }$ , is to learn a time series predictive model of the next state given the current state, $p ( \pmb { s } _ { t + 1 } | \pmb { s } _ { 1 : t } )$ from the expert state trajectories using time series modeling. In our case, we use an exponential of the difference between predicted states and actual next state associated with the action predicted by the policy network.
+
+$$
+r _ { t } ( s _ { t } , \mathbf { a } _ { t } ) = k \exp ( - \frac { \big \| \hat { s } _ { t + 1 } - f _ { E } \big ( s _ { t } , \mathbf { a } _ { t } \big ) \big \| ^ { 2 } } { 2 \sigma ^ { 2 } } ) \Bigg \rvert _ { \hat { s } _ { t + 1 } \sim p ( s _ { t + 1 } | s _ { 1 : t } ) }
+$$
+
+where $k$ is a constant controlling gain of the reward signal and $\sigma$ controls the sensitivity of reward to divergence from the predicted state. This reward can be used for guiding any standard model-free reinforcement learning techniques to maximize the expected reward, $R ( \pi _ { m f } ) =$ $\begin{array} { r } { \mathbb { E } _ { \pi _ { m f } } [ \sum _ { t } \gamma ^ { t } r _ { t } ( \pmb { s } _ { t } , \pmb { a } _ { t } ) ] } \end{array}$ . We assume on the intuition that locally optimal heuristic reward estimation will be sufficient to ensure global optimality for learning the desired task.
+
+![](images/f19202b5e0f6b95409afa642ff6ed7a7cac2cdb021baada62523aa71680e90be.jpg)  
+Figure 1: Showing the overall architecture of the proposed method. Firstly, model-free policy is updated using reward estimation from next state mismatch which storing the samples in replay buffer. These are used to update the differentiable dynamics model of the environment, which provides the error gradients for end-to-end model-based policy update from state trajectories
+
+# 2.2 MODEL-BASED IMITATION LEARNING FROM STATE TRAJECTORIES
+
+Consider there are $m$ sets of expert trajectory episode each consisting of $T$ states, given as $\tau _ { E } =$ $\{ s _ { 0 } , s _ { 1 } , . . . , s _ { n } \}$ , where $n = m T$ . We assume that the trajectories in each episode are independent of each other. For the imitation learning problem, we wish to imitate an expert agent $\pi _ { E }$ from state trajectories $\tau _ { E }$ . we formulate a maximum likelihood problem for state trajectories given a parameterized model of the agent policy, given as
+
+$$
+\pmb { \theta } ^ { * } = \underset { \pmb { \theta } } { \arg \operatorname* { m i n } } \Big [ - \sum _ { j = 1 } ^ { n } \sum _ { t = 1 } ^ { T } \log p \big ( s _ { t + 1 } \vert s _ { 1 : t } ; \theta \big ) \Big ] ,
+$$
+
+where $\pmb { \theta }$ represents the parameter of the model. We assume that the random variables state $\left( \boldsymbol { s } _ { t } \right)$ , action $\mathbf { \Pi } ( \mathbf { a } _ { t } )$ and next state $\mathbf { } s _ { t + 1 }$ form a directed graphical model as shown in figure 2 (b). Following the natural dynamics of environments in reinforcement learning setting, we assume that control action for the agent $a _ { t }$ is conditionally independent of other state and actions in the past given the current state. Distribution of the next state is conditionally independent of the other past states given current state and action following the MDP setting. In this framework, we can frame the modelbased policy as an encoder network with action as the latent variable and the dynamics policy as the decoder network predicting the next state. The log-likelihood estimation loss, in this case, can be written as,
+
+$$
+\mathcal { L } _ { s a s } = - \sum _ { j = 1 } ^ { m } \sum _ { t = 1 } ^ { T } \log \int _ { a } p ( s _ { t + 1 } | s _ { t } , a ; \theta _ { d } ) p ( a | s _ { t } ; \theta _ { e } ) d a ,
+$$
+
+where $\pmb { \theta } _ { e }$ , $t h e t a _ { d }$ are the encoder and decoder parameters respectively. Learning can be performed using $\left( \boldsymbol { s } _ { t } , \boldsymbol { s } _ { t + 1 } \right)$ pairs from the expert trajectories by minimizing the above loss, sampling action values from the posteriori distribution $p ( \pmb { a } _ { t } | \pmb { s } _ { t } )$ using standard Markov Chain Monte Carlo (MCMC) methods or variational inference methods Kingma $\&$ Ba (2015); Rezende et al. (2014). However, the learned action from the encoder in this case will not mimic the actual control commands used to perform the desired task in the control environment.
+
+We propose a constrained minimization cost function which enforces the decoder network to mimic the environment dynamics of the agent. The proposed cost function enforces that the decoders model minimizes the loss for dynamics model prediction of next state given the current state and action, whereas the composition of encoder over the decoder minimizes prediction loss of the next state given the current state. This loss function is given as,
+
+$$
+\begin{array} { r l } & { \mathcal { L } _ { p r o p o s e d } = - \mathbb { E } _ { ( s _ { t } , s _ { t + 1 } ) \sim \tau _ { E } } \bigg ( \log \int _ { a } p ( s _ { t + 1 } | s _ { t } , a ; \theta _ { d y n } ) p ( a | s _ { t } ; \theta _ { m b } ) d a \bigg ) } \\ & { \qquad - \mathbb { E } _ { ( s _ { t } , a _ { t } , s _ { t + 1 } ) \sim \tau _ { R L } } \bigg ( \log p ( s _ { t + 1 } | s _ { t } , a _ { t } ; \theta _ { d y n } ) \bigg ) , } \end{array}
+$$
+
+where we $\pmb { \theta } _ { d y n }$ are the parameters of dynamics model and $\pmb { \theta } _ { m b }$ are model-based policy network’s parameters. Let us denote the first term of the loss term in equation 4 as model-based policy loss, $\mathcal { L } _ { m b }$ and the second term is referred as dynamics model loss, $\mathcal { L } _ { d y n }$ . As shown in figure 1, we perform alternate minimizations on the proposed cost function and training on the encoder and decoder are performed on two separate datasets. Firstly, the dynamics model parameters are updated from the experience replay samples gathered during model-free exploration. Subsequently, the updated dynamics model is used as the decoder network in the above formulation with fixed weights while the model-based policy parameters are updated by the gradient, $\nabla _ { \theta _ { m b } } \mathcal { L } _ { m b }$ . This enforces the encoder network to act as a model-based policy that learns to predict the optimal action given the current state. During implementations, a deterministic encoder and decoder are used and a single action is sampled from the posterior distribution during training.
+
+# 2.2.1 LEARNING DYNAMICS MODEL FROM MODEL-FREE SAMPLES
+
+Since our expert trajectories only consist of sensory streams containing state information only, learning from the heuristic reward in a MDP setting can be slow and does not guarantee that the reward is optimal for the desired task. Thus we resort to dynamics model based learning which can propagate error gradients with respect to action information as discussed in the above section. Consider an analogy of a robot learning to navigate through a maze of expert state information only. It must first learn the state transition model $p ( \pmb { s } _ { t + 1 } | \pmb { s } _ { t } , \pmb { a } _ { t } )$ to navigate through the environment. Once dynamics model is learned, it can obtain the best action that takes the current state in optimal state trajectories to the next state. Solving for the desired action at each state $\left( \boldsymbol { p } ( \boldsymbol { a } _ { t } | \boldsymbol { s } _ { t } ) \right)$ is a maximum likelihood problem from the expert state trajectories which can be solved by end-to-end supervised learning.
+
+Let us assume we have a parameterized model for agent dynamics, given as $\pmb { s } _ { t + 1 } = f ( \pmb { s } _ { t } , \pmb { a } _ { t } ; \pmb { \theta } _ { d y n } )$ , where $\pmb { \theta } _ { d y n }$ denotes parameters of the model. During model-free learning, we store the trajectories of $( s _ { t } , a _ { t } , s _ { t + 1 } )$ that were encountered during exploration by the agent. Let us denotes the trajectories of these triplets as $\tau _ { R L }$ . For continuous state spaces, the gradient for dynamic model parameters are given as
+
+$$
+\nabla _ { \theta _ { d y n } } \mathcal { L } _ { d y n } = \nabla _ { \theta _ { d y n } } \mathbb { E } _ { ( s _ { t } , a _ { t } , s _ { t + 1 } ) \sim \tau _ { R L } } \Big [ \| f \big ( s _ { t } , a _ { t } ; \theta _ { d y n } \big ) - s _ { t + 1 } \| _ { 2 } ^ { 2 } \Big ]
+$$
+
+which is gradient on the mean squared error loss between model predicted and true next state. For the discrete state space case, we can first maximize the probability of next state given the current state and action using a categorical loss. Any standard stochastic gradient descent algorithms can be used for the above optimizations. However, we use neural networks as function approximators which are shown to have approximation capacity for arbitrary non-linear function, although its nonconvex nature of optimization does always guarantee a solution that is globally optimal. Recent techniques in stochastic gradient descent (Zeiler (2012); Kingma & Ba (2014) ) have alleviated this problem to a large extent.
+
+If we assume the dynamics model is ideal in predicting the next state and there exists a unique action to reach the next state from the current state, then the proposed method is identical to behavior cloning, although true action information is not provided by the expert. Therefore, the performance of this method is upper bounded by the performance of behavior cloning model which learns from the true action information between states.
+
+# 2.3 TRANSFORMING STATES BASED ON ACTION
+
+In our formulation so far, the entire next state of the agent is predicted by the next state predictor. However, we found that predicting a part of the state which is dependent on action gives better reward structure. This is in line with the work of Pathak et al. (2017), where the authors predict $\phi ( \pmb { s } _ { t } )$ as the latent representation of the neural network predicting the action from consecutive states, $\pmb { a } _ { t } = g ( \phi ( \pmb { s } _ { t } ) , \phi ( \pmb { s } _ { t + 1 } ) )$ . This transformed state value, $\phi ( \pmb { s } _ { t } )$ is also used as the input and output for the dynamics model. This transformation is beneficial for two reasons: (i) It is difficult to learn the dynamics model for high dimensional state information and thus first projecting onto a low dimensional manifold to learn the dynamics model gives a more feasible learning framework. (ii) In case of transferring the learned dynamics model between different tasks that use the same environment, a common state input is required for the dynamics model, which can be achieved such transformation. In case of learning from videos, we use the agent position in the image frames as $\phi ( s _ { t } )$ . For the case of linked arm reacher, we will use $p h i ( s _ { t } )$ as the joint angles and joint velocities.
+
+# 2.4 ALGORITHM
+
+We now outline the algorithm based on the above discussed model-based policy learning framework.
+
+# Algorithm 1 Model based imitation learning from state trajectories
+
+1: Input : Given expert trajectories $\tau _ { E }$ , initial parameters $\theta _ { m b } ^ { 0 } , \theta _ { m f } ^ { 0 }$ and $\theta _ { d y n } ^ { 0 }$ and the state transformation $\phi ( . )$   
+2: Learn next state predictor model $\begin{array} { r } { \theta _ { p } \gets \arg \operatorname* { m i n } _ { \theta _ { p } } - \mathbb { E } _ { \{ s _ { 1 : t + 1 } \} \sim \tau _ { E } } \log p ( \phi ( s _ { t + 1 } ) | s _ { 1 : t } ; \theta _ { p } ) } \end{array}$   
+3: for $k = 1 , 2 , 3 , \ldots$ do   
+4: Sample trajectory from model-free policy $\tau _ { k } \in \pi _ { m f } ^ { k }$ and add to the replay buffer $\tau _ { R L }$   
+5: Updated the dynamics model parameter using trajectories from the replay buffer $\begin{array} { r } { \theta _ { d y n } ^ { k + 1 } \gets \arg \operatorname* { m i n } _ { \theta _ { d y n } ^ { k } } - \mathbb { E } _ { ( s _ { t } , a _ { t } , s _ { t + 1 } ) \sim \tau _ { R L } } \Big ( \log p ( \phi ( s _ { t + 1 } ) | \phi ( s _ { t } ) , a _ { t } ; \theta _ { d y n } ^ { k } ) \Big ) } \end{array}$   
+6: Update model based parameter from expert trajectories with fixed dynamics model. $\begin{array} { r } { \theta _ { m b } ^ { k + 1 }  \mathrm { a r g } \operatorname* { m i n } _ { \theta _ { m b } ^ { k } } - \mathbb { E } _ { ( s _ { t } , s _ { t + 1 } ) \sim \tau _ { E } } \Big ( \log \sum _ { a } p ( \phi ( s _ { t + 1 } ) | \phi ( s _ { t } ) , a ; \theta _ { d y n } ^ { k + 1 } ) p ( a | s _ { t } ; \theta _ { m b } ^ { k } ) \Big ) } \end{array}$   
+7: end for
+
+The above algorithm shows an iterative process where in each iteration we first train a model-free algorithm using the heuristic reward function. This step is necessary because we collect a certain amount of system dynamics data, $( s _ { t } , a _ { t } , s _ { t + 1 } )$ , while training the model-free policy. Then, we train a system dynamics model using the above collected data. The action policy is then trained using the system dynamics model in the model-based part, which constitutes one cycle of the training. Subsequently, we repeat this cycle again starting from the model-free part. With each iteration, we collect additional system dynamics data, which results in a more precise dynamics model, leading to accurate action policy parameter gradients for updating the model-based policy.
+
+The frequency of switching between model-free replay buffer collection and model-based update can be varied depending on the complexity of dynamics model. For state predictions from previous states, we used Long Short-Term Memory Network, proposed by Hochreiter & Schmidhuber (1997). For the policy and dynamics model, we use neural networks as function approximators. In this work, we assume that the state transformation $\phi ( . )$ is manually specified in each experiments, although it is possible to learn such representation by learning a common transformation between states that predicts the action, $\pmb { a } _ { t } = g ( \bar { \phi } ( \pmb { s } _ { t } ) , \phi ( \pmb { s } _ { t + 1 } ) )$ .
+
+# 3 EXPERIMENTAL RESULTS
+
+We perform experimental evaluations on three kinds of environment, (i) Robotics arm reacher in 2d, (ii) Simple 2d obstacle avoidance based reacher, (iii) Learning to play simple games from raw video demonstrations. In each experiment, we show specific strengths of the proposed algorithm as follows.
+
+![](images/6379de053f41f22153fb46930d318a0004dd4610fb254fceff4719bb5936a40d.jpg)  
+Figure 2: (a) Showing the toy obstacle avoidance environment used in our experiments, (b) The directed graphical model, which shows that next is dependent on current state and action, while current action is just dependent of the current state
+
+# 3.1 ROBOTICS ARM REACHER IN 2D
+
+We use roboschool reacher(OpenAI (2017); Brockman et al. (2016) environment to simulate twolink robotic arm that can move in two-dimensional space. The desired task is to learn reaching a given target from random starting configurations. The arm is controlled using angular torque values of both joints. We use state values consisting of angular position, angular velocity, the end effector location of the robotic link and the position of the target. The robotic arm angles and angular velocities were used as $\phi ( \pmb { s } _ { t } )$ , which is the portion of state dependent on action. In this experiment, we assume that the true reward function is known and in addition, we have some state trajectories from the expert policy. The goal is to leverage these existing state trajectories to learn a better policy in less number of steps. Reward signal, consisting of distance potential, electricity cost and the penalty for stuck joint, which is the default reward specified for the environment, was used. Specifically, we show 500 trajectories of optimal states each with 100 steps to learn model-based policy using the proposed method. We used neural networks with hidden layers containing (128, 64) neurons for both model-based and model-free policies. Training was performed over 2000 episodes using Deep Deterministic Policy Gradients(DDPG) proposed by Lillicrap et al. (2016).
+
+Figure 3(a) shows the comparison of proposed method against the DDPG algorithm. Our method learns the dynamics model from the model-free exploration, which quickly learns the simple environment dynamics, in this case, thereby learning an optimal policy imitating the state trajectories much faster than model-free training, which is shown in results. However, we found this is due to a large number of state trajectories that are shown to the proposed method. Since our performance is upper bounded by behavior cloning results, we share the same drawbacks of compounding errors and data-hungry policy learning.
+
+# 3.2 2D OBSTACLE AVOIDER
+
+In this experiment, we demonstrate that proposed algorithm can be used for direct end-to-end supervised imitation learning on novel tasks without resorting to model-free reinforcement learning. We refer to this setup as one-shot imitation learning, which we demonstrate on a simple toy environment. The environment is shown in figure 2(a). The environment consists of an agent which can freely move in 2D space. The agent is controlled by continuous position control where the action is the change in $( x , y )$ agent position at each time step. The goal is to reach the target location while avoiding the obstacle. Initially, we train our algorithm on an environment to avoid a single obstacle while reaching the target. We use state information as the absolute position of the agent, target and obstacle, the agent velocity and relative location of obstacle and target with respect to the agent. We use $\phi ( \pmb { s } _ { t } )$ as the agent 2d position in the environment.
+
+![](images/a7ab005a861fb80546c60fe40dfda21edd68746a9c51640b92400c9b7e917e99.jpg)  
+Figure 3: (a) Comparison of proposed method with model-free reinforcement learning methods, behavior cloning and proposed model-based method for Flappy birds. The model-based method is shown to surpass the model-free method in test reward performance with much less iterations, although being upper bounded by behavior cloning results (b) Comparison of the proposed method with continuous model-free methods on roboschool reacher showing better convergence performance with less iterations
+
+For expert demonstration, we implemented a manually engineered policy that always avoids the obstacle. We used 1000 number of demonstrations containing only state trajectories to reach a target while avoiding a single obstacle. Out of 1000 demonstrations, 800 are used for training and 200 for validation. We first learn the time series prediction of the next state, used to compute the heuristic reward based using prediction error as discussed in section 2.1. For model-based policy, we use a MLP with (64, 64) hidden units. We use the same policy network for both model-based and modelfree policy. The dynamics model is also modeled as a neural network with a single hidden layer of 8 units for both state and action input. We used a switching frequency of 5 between the model-free and model-based updates. Using these setting for the proposed algorithm, we get a model-based policy and the dynamics model as output.
+
+Using the dynamics model obtained from training with demonstrations of single obstacle avoidance, we perform one-shot imitation learning to learn avoidance of two obstacles. The algorithm is presented 500 samples of expert state trajectories for avoiding two obstacles. The model-based policy in the new setting is learned by step 6 of the proposed algorithm 1 using the previously learned dynamics model. Although the state information for the policy networks might change due to an additional obstacle, since $\phi ( s _ { t } )$ , which is the agent 2d location, remains same in both cases, we can perform one-shot imitation learning in this case. We compare the results with respect to the expert policy and behavior cloning and report the average of test reward on 50 episodes. While the expert policy achieves average test reward of 3036, and behavior cloning achieves 3939 and our imitation learning method gave a reward of 3805. This demonstrates that our proposed algorithm can be used for one-shot imitation in environments with same dynamics and can produce comparable results to behavior cloning which was trained from true actions.
+
+# 3.3 LEARNING POLICIES FROM RAW VIDEOS
+
+In this experiment, we learn model-based control policies from raw pixels. We use the python reimplementation of the game Flappy bird (Lau (2017)). In this environment, the agent has to hover through the pipes without collision by flapping its wings. The environment has gravity and with each flap, the agent receives an upward acceleration which sends it to an upward parabolic trajectory. We choose this environment due to its complicated dynamics and show that our proposed method can learn to model this dynamics. We learn action policies from raw videos of just 10 episodes each with 1000 steps. The reward is assumed to be unknown in this case and we estimate the reward by the error in prediction of the next state as mentioned in section 2.1. The control action is a single discrete command of whether to flap the bird’s wings or not. We denotes this action space as $\{ + 1 , - 1 \}$ . For state information at each step we use 4 consecutive frames resized to $( 8 0 \times 8 0 \times 4 )$ . We also assume that the absolute position of the bird’s location is available to us, which we use as $\phi ( s _ { t } )$ . This can be also computed by learning a simple object detector from image frames.
+
+For the next state predictor, we use an LSTM predictor that outputs the next position of the agent location given the sequence of states witnessed so far. The model-free reward prediction step receives a reward signal based on the difference of the actual next state taken the policy, from the predicted next state by LSTM. This reward is used to train DQN(Mnih et al. (2015)) for model-free policy update which collects data to train the dynamics model, which in turn trains the model-based policy network. We also train vanilla DQN using a standard reward, which in this case is 0.1 for each time step and $+ 1$ reward if the agent can successfully pass through a pipe. To compare the various methods, we used the reward used by vanilla DQN as a baseline for comparison.
+
+For the model-based policy we used a convolutional neural network (CNN) with soft-max output, which is essentially a binary classification task. For the DQN model-free policy, the last layer predicts the $\mathsf { q }$ -values and therefore has linearly activation. In this case, we first learn dynamics model, which is approximated as a multi layered perceptron (MLP) with single hidden layer of 16 units for both state and action inputs. It learns to regress the next state from the current state and actions minimizing mean squared error loss. After this, from the expert demonstration of state trajectory $( \tau _ { E } )$ , we find the current optimal action that minimizes the next state a∗k = arg mina kp(st+1 − f (st, at)k|at∈{0,1},{st+1,st}∼τE . The next step is to find the modelbased policy by behavior cloning on the states $( \boldsymbol { s } _ { t } \sim \tau _ { E } )$ and current optimal actions, $\pmb { a } _ { k } ^ { * }$ . We found that, the number of $+ 1 ( \mathbb { I a p } )$ actions by the agent are far less frequent compared to the number of -1(no flap) actions which cause an unbalance in distribution. Thus, we used class balancing techniques for learning both model based policy update and direct behavior cloning from true actions (baseline) results.
+
+Figure 3(b) shows the comparison of proposed model-based method with estimated reward (mb reward pred), behavior cloning $( b c )$ , model-free RL using DQN with standard known reward (dqn reward) and with estimated reward (dqn reward pred). It is to be noted that although original reward just provides a constant reward (of 0.1 and $+ 1$ bonus) without constant guidance at each step value, estimated reward provides a dense guidance signal which leads to faster convergence as shown in the comparison results. We take desired samples from the model-free training, based on prioritized sampling technique with regards to the estimated reward signal, to perform model-based policy update. We found that prioritized sampling was essential to learn a good dynamics model of the environment. The results show that the model-based policy learns behavior close to optimal in much fewer steps compared to the model-free counterparts. However, its performance in upper bounded by the behavior cloning method which achieves an average test reward (over 20 iterations) of 49.62. The expert score is 60.9. Since DQN with estimated reward signal learns via exploration in a MDP setting, it can surpass the performance of behavior cloning since the number of expert demonstrations is limited in this case.
+
+# 4 CONCLUSION
+
+We presented a model-based imitation learning method that can learn to act from expert state trajectories in the absence of action information. Our method uses trajectories sampled from the modelfree policy exploration to train a dynamics model of the environment. As model-free policy is enriched through time, the forward model can better approximate the actual environment dynamics, which leads to improved gradient flow, leading to better model-based policy update which is trained in a supervised fashion from expert state trajectories. In the ideal case, when dynamics model perfectly approximates the environment, our proposed method is equivalent to behavior cloning, even in the absence of action information. We demonstrate that the proposed method learns the desired policy in less number of iterations compared conventional model-free methods. We also show that once the dynamics model is trained it can be used to transfer learning for other tasks in a similar environment in an end-to-end supervised manner. Future work includes tighter integration of the model-based learning and the model-free learning for higher data efficiency by sharing information (1) between the model-free policy $\pi _ { m f }$ and the model-based policy $\pi _ { m b }$ and (2) between the next state predictor $p ( s _ { t + 1 } | s _ { t } )$ and the dynamics model $p ( \pmb { s } _ { t + 1 } | \pmb { s } _ { t } , \pmb { a } _ { t } )$ and (3) improving the limitations of compounding errors and requirement of large number of demonstration, by adversarial training which can maximize likelihood of future state distributions as well.
+
+# REFERENCES
+
+Nir Baram, Oron Anschel, Itai Caspi, and Shie Mannor. End-to-end differentiable adversarial imitation learning. In Doina Precup and Yee Whye Teh (eds.), Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pp. 390–399, International Convention Centre, Sydney, Australia, 06–11 Aug 2017. PMLR. URL http://proceedings.mlr.press/v70/baram17a.html.
+
+Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym, 2016. URL http://gym.openai.com/.
+
+Yan Duan, Marcin Andrychowicz, Bradly Stadie, Jonathan Ho, Jonas Schneider, Ilya Sutskever, Pieter Abbeel, and Wojciech Zaremba. One-shot imitation learning. arXiv preprint arXiv:1703.07326, 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, pp. 2672–2680, 2014.
+
+Jonathan Ho and Stefano Ermon. Generative adversarial imitation learning. In Advances in Neural Information Processing Systems, pp. 4565–4573, 2016.
+
+Sepp Hochreiter and Jrgen Schmidhuber. Long short-term memory. Neural Computation, 9(8): 1735–1780, 1997. doi: 10.1162/neco.1997.9.8.1735. URL https://doi.org/10.1162/ neco.1997.9.8.1735.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In The International Conference on Learning Representations (ICLR), volume abs/1412.6980, USA, 2015. URL http://arxiv.org/abs/1412.6980.
+
+Ben Lau. Keras-flappybird. https://github.com/yanpanlau/Keras-FlappyBird, 2017.
+
+Timothy Lillicrap, Jonathan Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. In The International Conference on Learning Representations (ICLR), San Juan, Puerto Rico, 2016. URL http://arxiv.org/abs/1509.02971.
+
+YuXuan Liu, Abhishek Gupta, Pieter Abbeel, and Sergey Levine. Imitation from observation: Learning to imitate behaviors from raw video via context translation. arXiv preprint arXiv:1707.03374, 2017.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin Riedmiller, Andreas K. Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, Feb 2015. ISSN 0028-0836.
+
+Andrew Y. Ng and Stuart J. Russell. Algorithms for inverse reinforcement learning. In Proceedings of the Seventeenth International Conference on Machine Learning, ICML ’00, pp. 663–670, San Francisco, CA, USA, 2000. Morgan Kaufmann Publishers Inc. ISBN 1-55860-707-2. URL http://dl.acm.org/citation.cfm?id=645529.657801.
+
+OpenAI. Roboschool. https://github.com/openai/roboschool, 2017.
+
+Deepak Pathak, Pulkit Agrawal, Alexei A. Efros, and Trevor Darrell. Curiosity-driven exploration by self-supervised prediction. In International Conference on Machine Learning (ICML), 2017.
+
+Dean A Pomerleau. Efficient training of artificial neural networks for autonomous navigation. Neural Computation, 3(1):88–97, 1991.
+
+Danilo J Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In Proceedings of the 31st International Conference on Machine Learning (ICML-14), pp. 1278–1286, 2014.
+
+Stephane Ross and Drew Bagnell. Efficient reductions for imitation learning. In ´ Proceedings of the thirteenth international conference on artificial intelligence and statistics, pp. 661–668, 2010.
+
+Stephane Ross, Geoffrey J Gordon, and Drew Bagnell. A reduction of imitation learning and struc- ´ tured prediction to no-regret online learning. In International Conference on Artificial Intelligence and Statistics, pp. 627–635, 2011.
+
+John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In Proceedings of the 32nd International Conference on Machine Learning (ICML-15), pp. 1889–1897, 2015.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
+
+Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction, volume 1. MIT press Cambridge, 1998.
+
+Richard Stuart Sutton. Temporal credit assignment in reinforcement learning. 1984.
+
+Ziyu Wang, Josh Merel, Scott Reed, Greg Wayne, Nando de Freitas, and Nicolas Heess. Robust imitation of diverse behaviors. arXiv preprint arXiv:1707.02747, 2017.
+
+Matthew D Zeiler. Adadelta: an adaptive learning rate method. arXiv preprint arXiv:1212.5701, 2012.
+
+Brian D Ziebart, Andrew L Maas, J Andrew Bagnell, and Anind K Dey. Maximum entropy inverse reinforcement learning. In AAAI, volume 8, pp. 1433–1438. Chicago, IL, USA, 2008.

parse/train/S1GDXzb0b/S1GDXzb0b_content_list.json

@@ -0,0 +1,1097 @@
+[
+    {
+        "type": "text",
+        "text": "MODEL-BASED IMITATION LEARNING FROM STATE TRAJECTORIES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            625,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Imitation learning from demonstrations usually relies on learning a policy from trajectories of optimal states and actions. However, in real life expert demonstrations, often the action information is missing and only state trajectories are available. We present a model-based imitation learning method that can learn environment-specific optimal actions only from expert state trajectories. Our proposed method starts with a model-free reinforcement learning algorithm with a heuristic reward signal to sample environment dynamics, which is then used to train the state-transition probability. Subsequently, we learn the optimal actions from expert state trajectories by supervised learning, while back-propagating the error gradients through the modeled environment dynamics. Experimental evaluations show that our proposed method successfully achieves performance similar to (state, action) trajectory-based traditional imitation learning methods even in the absence of action information, with much fewer iterations compared to conventional model-free reinforcement learning methods. We also demonstrate that our method can learn to act from only video demonstrations of expert agent for simple games and can learn to achieve desired performance in less number of iterations. ",
+        "bbox": [
+            233,
+            267,
+            764,
+            489
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            516,
+            336,
+            532
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement learning(RL) involves training an agent to learn a policy that accomplishes a certain task in an environment. The objective of reinforcement learning is to maximize the expected future reward Sutton & Barto (1998) from a guiding signal. Mnih et al. (2015) showed that neural networks can be used to approximate state-action value functions used by an agent to perform discrete control based on a guiding reward. This was demonstrated in Atari games where the score was used as the reward signal. Similarly, continuous control of robotics arm was achieved by Lillicrap et al. (2016) minimizing the distance between end-effector and target location. Following these, other methods such as Schulman et al. (2017; 2015) were proposed to improve the sample efficiency of modelfree algorithms with theoretical guarantees of policy improvement in each step. These algorithms assume that a guiding reward signal is available for the agent to learn optimal behavior for a certain task. However, in most cases of natural learning, such guiding signal is not present and learning is performed by imitating an expert behavior. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            714
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Imitation learning involves copying the behavior of an expert agent to accomplish the desired task. In the conventional imitation learning setting, a set of expert trajectories providing states and optimal actions $\\tau = \\{ s _ { 0 } , { \\pmb a } _ { 0 } , { \\pmb s } _ { 1 } , { \\pmb a } _ { 1 } , . . . , { \\pmb s } _ { n } , { \\pmb a } _ { n } \\}$ performed by an expert agent $\\pi _ { E }$ are available but the reward (or cost function), $r _ { E } ( s , a )$ used to achieve the expert behavior is not available. The goal is to learn a new policy $\\pi$ , which imitates the expert behavior by maximizing the likelihood of given demonstration trajectories. ",
+        "bbox": [
+            174,
+            722,
+            823,
+            805
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A straightforward way for imitation learning is to direct learn the optimal action to perform given the current state as proposed by Pomerleau (1991); Duan et al. (2017). The policy $\\pi$ can learn to imitate the expert behavior by maximizing likelihood of the condition distribution of action given states $p ( \\pmb { a } | \\pmb { s } )$ . This can be achieved by simply training a parameterized function (neural networks for instance) with state and action pairs from the expert trajectories. Since this involves end-to-end supervised learning, training is much more sample-efficient compared to reinforcement learning and overcomes inherent problems in model-free methods such as credit assignment(Sutton (1984)). However, since behavior cloning learns optimal action from a single state value only, it is unaware of the future state distribution the current action will produce. Thus, errors are compounded in the future states leading to undesired agent behavior as shown by Ross et al. (2011); Ross & Bagnell (2010). Therefore, numerous training samples are required for behavior cloning to reduce errors in action prediction required for satisfactory imitation learning. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The second approach to imitation learning involves setting up exploration in a Markov Decision Process(MDP) setting. The goal then is to recover a reward signal that best explains the expert trajectories. $\\mathrm { N g }$ & Russell (2000) first introduced Inverse Reinforcement Learning(IRL), where the goal is to find a reward signal $\\hat { r }$ from the trajectories such that the expert is uniquely optimal. After computing this estimated reward signal, usually, a model-free reinforcement learning performed to obtain the desired policy imitating the expert behavior by maximizing the expected discounted reward $\\begin{array} { r } { \\mathbb { E } _ { \\pi } \\big ( \\sum _ { t } \\gamma ^ { t } \\hat { r } \\big ( s _ { t } , \\dot { a } _ { t } \\big ) \\big ) } \\end{array}$ . While this alleviates the problem of compounding errors as in behavior cloning, Ziebart et al. (2008) showed that estimating a unique reward function from state and action trajectories is an ill-posed problem. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            291
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Following the success of Generative Adversarial Networks(GANs) (Goodfellow et al. (2014)) in various fields of machine learning, adversarial learning has also been shown incorporated in the imitation learning framework. The recent work on Generative Adversarial Imitation Leaning or GAIL by Ho & Ermon (2016) showed that model-free reinforcement learning using the discriminator as a cost function can learn to imitate the expert agent with much less number of demonstrated trajectories compared to behavior cloning. Following the success of GAIL, there have extensions by Baram et al. (2017) to model-based generative imitation learning using a differentiable dynamics model of the environment. Robust imitation policy strategies using a combination of variational autoencoders (Kingma & Ba (2015); Rezende et al. (2014)) and GAIL has also been proposed by Wang et al. (2017). ",
+        "bbox": [
+            174,
+            297,
+            825,
+            438
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The previous works assume that the expert trajectories consist of both action and state values from the optimal agent. However, optimal actions are usually not available in real-world imitation learning. For example, we often learn tasks like skipping, jump rope, gymnastics, etc. just by watching other expert humans perform the task. In this case, the optimal expert trajectories only consist of visual input, in other words, the consecutive states of the expert human with no action information. We learn to jump rope by trying to reproduce actions that result in state trajectories similar to the state trajectories observed from the expert. This requires exploring the environment in a structured fashion to learn the dynamics of the rope (for jump rope) which then enables executing optimal actions to imitate the expert behavior. The recent work of Liu et al. (2017) presents learning from observations only with focus to transferring skills learned from source domain to an unseen target domain, using rewards obtained by feature tracking for model-free reinforcement learning. ",
+        "bbox": [
+            173,
+            444,
+            825,
+            597
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Inspired by the above method of learning in humans, we present a principled way of learning to imitate an expert from state information only, with no action information available. We first learn a distribution of the next state from the current state trajectory, used to estimate a heuristic reward signal enabling model-free exploration. The state, action and next states information from modelfree exploration is used to learn a dynamics model of the environment. For the case of learning in humans, this is similar to performing actions for replicating the witnessed expert state trajectories, which in turn gives information about the dynamics of the environment. Once this forward model is learned, we try to find the action that maximizes the likelihood of next state. Since the forward model gives a function approximation for the environment dynamics, we can back propagate errors through it to perform model-based policy update by end to end supervised learning. We demonstrate that our proposed network can reach, with fewer iterations, the level close to an expert agent behavior (which is a pre-trained actor network or manually provided by humans), and compare it with reinforcement learning using a hand-crafted reward or a heuristics reward that is based on prediction error of next state learned from the optimal state trajectories of the expert. ",
+        "bbox": [
+            174,
+            604,
+            825,
+            799
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1.1 NOTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            824,
+            295,
+            838
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We summarize the notations used in the paper in this section. Consider a Markov Decision Process (MDP) denoted as $( S , A , P , r , \\rho _ { 0 } , \\gamma )$ , where $S$ is the finite set of states, $A$ is the set of possible actions, $P : S \\times A \\to S$ is the transition probability distribution and $r : S \\times A \\to \\mathbb { R }$ be the reward signal from state and actions, $\\rho _ { 0 }  \\mathcal { R }$ is the initial state distribution and $\\gamma \\in ( 0 , 1 )$ is the discount factor. Let $\\pi : S \\times A \\to ( 0 , 1 )$ be the policy that gives the conditional distribution of actions given current state, $p ( \\pmb { a } | \\pmb { s } )$ and $R ( \\pi ) = \\mathbb { E } _ { \\pi } [ \\sum _ { t } \\gamma ^ { t } r _ { t } ( s _ { t } , { \\pmb a } _ { t } ) ]$ is the discounted reward associated with the policy. We consider expert trajectories consisting of only optimal state distribution without any action information, $\\tau _ { E } = \\{ s _ { 0 } , s _ { 1 } , . . . , s _ { n } \\}$ . The trajectories sampled from model-free exploration is denoted as, $\\tau _ { R L } = \\{ s _ { 0 } , { a _ { 0 } } , { s _ { 1 } } , { a _ { 1 } } , . . . , { s _ { n } } , { a _ { n } } \\}$ . We use the terms dynamic model, state-transition probability and forward model interchangeably in the paper. $f _ { E } ( \\pmb { s } _ { t } , \\pmb { a } _ { t } )$ denotes the non-differentiable forward model of the environment and $f ( \\pmb { s } _ { t } , \\pmb { a } _ { t } )$ denotes the differentiable version which is learned during the proposed training procedure. $\\pi _ { m f }$ denotes the model-free policy and $\\pi _ { m b }$ denotes the model-based policy network. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            102,
+            825,
+            215
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 PROPOSED METHOD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            241,
+            372,
+            257
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "While most previous works use trajectories containing both state and action information to infer a policy that imitates the expert behavior, our problem statement is to imitate an expert from optimal state trajectories only. This setting is common in many natural scenarios where only state information is available. For example, humans learning to swim by seeing videos or observing other experts swimmers, have access to the sensory stream of information containing states only. The optimal actions are obtained by trying to replicate the state trajectories in the real environment via exploration. In this work, we learn a time series predictor of next state given the current state. Subsequently, we estimate a heuristic reward signal at each step, based on the difference of predicted next state by the time series model and the actual next state taken by the policy network to learn a model-free policy with exploration. However, such heuristic methods suffer from the disadvantages of slow modelfree training to reach satisfactory policy and provide no guarantees on convergence. Therefore we resort to model-based policy learning that learns a differentiable model of the environment dynamics used to learn policy by directly supervised learning. The proposed algorithm alternates between dynamic model parameters and policy parameters update using gradient propagation through the differentiable dynamics model. We formalize this setup in the following sections. ",
+        "bbox": [
+            174,
+            276,
+            825,
+            484
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 MODEL-FREE POLICY LEARNING VIA REWARD ESTIMATION",
+        "text_level": 1,
+        "bbox": [
+            176,
+            508,
+            625,
+            522
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Following the work in Inverse Reinforcement Learning(IRL), it is possible to frame the imitation learning problem in the MDP framework. The imitation learning problem then reduces to finding a uniquely optimal reward signal that maximizes the likelihood of the observed demonstration trajectories. However, finding a uniquely optimal reward function, even with optimal trajectories containing both state and action information, is an ill-posed problem. The ill-posed nature of optimal reward estimation is further accentuated in the absence of action information in expert trajectories. As such, many solutions for parameterized families of reward estimation models maximizing the likelihood of only expert state trajectories might be sub-optimal to learn the desired task. ",
+        "bbox": [
+            173,
+            535,
+            825,
+            647
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For model-free policy learning, we use a heuristic reward estimated by the error in next state prediction at each step. We make an assumption that estimating a locally optimal reward maximizing the likelihood of next step predicting, is intuitively globally optimal for learning the desired task. A straight-forward method to obtain such heuristic reward signal from the trajectories, $\\tau _ { s }$ , is to learn a time series predictive model of the next state given the current state, $p ( \\pmb { s } _ { t + 1 } | \\pmb { s } _ { 1 : t } )$ from the expert state trajectories using time series modeling. In our case, we use an exponential of the difference between predicted states and actual next state associated with the action predicted by the policy network. ",
+        "bbox": [
+            173,
+            655,
+            825,
+            766
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/859c6fba08d381e3d073a3bd38dd56546c330436d9e23acdb9bc662dec498af9.jpg",
+        "text": "$$\nr _ { t } ( s _ { t } , \\mathbf { a } _ { t } ) = k \\exp ( - \\frac { \\big \\| \\hat { s } _ { t + 1 } - f _ { E } \\big ( s _ { t } , \\mathbf { a } _ { t } \\big ) \\big \\| ^ { 2 } } { 2 \\sigma ^ { 2 } } ) \\Bigg \\rvert _ { \\hat { s } _ { t + 1 } \\sim p ( s _ { t + 1 } | s _ { 1 : t } ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            790,
+            704,
+            837
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $k$ is a constant controlling gain of the reward signal and $\\sigma$ controls the sensitivity of reward to divergence from the predicted state. This reward can be used for guiding any standard model-free reinforcement learning techniques to maximize the expected reward, $R ( \\pi _ { m f } ) =$ $\\begin{array} { r } { \\mathbb { E } _ { \\pi _ { m f } } [ \\sum _ { t } \\gamma ^ { t } r _ { t } ( \\pmb { s } _ { t } , \\pmb { a } _ { t } ) ] } \\end{array}$ . We assume on the intuition that locally optimal heuristic reward estimation will be sufficient to ensure global optimality for learning the desired task. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/f19202b5e0f6b95409afa642ff6ed7a7cac2cdb021baada62523aa71680e90be.jpg",
+        "image_caption": [
+            "Figure 1: Showing the overall architecture of the proposed method. Firstly, model-free policy is updated using reward estimation from next state mismatch which storing the samples in replay buffer. These are used to update the differentiable dynamics model of the environment, which provides the error gradients for end-to-end model-based policy update from state trajectories "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            99,
+            807,
+            329
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 MODEL-BASED IMITATION LEARNING FROM STATE TRAJECTORIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            428,
+            671,
+            443
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Consider there are $m$ sets of expert trajectory episode each consisting of $T$ states, given as $\\tau _ { E } =$ $\\{ s _ { 0 } , s _ { 1 } , . . . , s _ { n } \\}$ , where $n = m T$ . We assume that the trajectories in each episode are independent of each other. For the imitation learning problem, we wish to imitate an expert agent $\\pi _ { E }$ from state trajectories $\\tau _ { E }$ . we formulate a maximum likelihood problem for state trajectories given a parameterized model of the agent policy, given as ",
+        "bbox": [
+            173,
+            453,
+            825,
+            525
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/26aec1afda4a6b239c9d3fcd5278e9ef74ce42db2ff2b79c7506c87dbad0de5f.jpg",
+        "text": "$$\n\\pmb { \\theta } ^ { * } = \\underset { \\pmb { \\theta } } { \\arg \\operatorname* { m i n } } \\Big [ - \\sum _ { j = 1 } ^ { n } \\sum _ { t = 1 } ^ { T } \\log p \\big ( s _ { t + 1 } \\vert s _ { 1 : t } ; \\theta \\big ) \\Big ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            540,
+            656,
+            585
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\pmb { \\theta }$ represents the parameter of the model. We assume that the random variables state $\\left( \\boldsymbol { s } _ { t } \\right)$ , action $\\mathbf { \\Pi } ( \\mathbf { a } _ { t } )$ and next state $\\mathbf { } s _ { t + 1 }$ form a directed graphical model as shown in figure 2 (b). Following the natural dynamics of environments in reinforcement learning setting, we assume that control action for the agent $a _ { t }$ is conditionally independent of other state and actions in the past given the current state. Distribution of the next state is conditionally independent of the other past states given current state and action following the MDP setting. In this framework, we can frame the modelbased policy as an encoder network with action as the latent variable and the dynamics policy as the decoder network predicting the next state. The log-likelihood estimation loss, in this case, can be written as, ",
+        "bbox": [
+            173,
+            594,
+            825,
+            720
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c6ee91bac80d20a058bd4bfb9ddd467318d6d28a33f4d71a7e52b2ec3a96e89b.jpg",
+        "text": "$$\n\\mathcal { L } _ { s a s } = - \\sum _ { j = 1 } ^ { m } \\sum _ { t = 1 } ^ { T } \\log \\int _ { a } p ( s _ { t + 1 } | s _ { t } , a ; \\theta _ { d } ) p ( a | s _ { t } ; \\theta _ { e } ) d a ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            307,
+            736,
+            689,
+            781
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\pmb { \\theta } _ { e }$ , $t h e t a _ { d }$ are the encoder and decoder parameters respectively. Learning can be performed using $\\left( \\boldsymbol { s } _ { t } , \\boldsymbol { s } _ { t + 1 } \\right)$ pairs from the expert trajectories by minimizing the above loss, sampling action values from the posteriori distribution $p ( \\pmb { a } _ { t } | \\pmb { s } _ { t } )$ using standard Markov Chain Monte Carlo (MCMC) methods or variational inference methods Kingma $\\&$ Ba (2015); Rezende et al. (2014). However, the learned action from the encoder in this case will not mimic the actual control commands used to perform the desired task in the control environment. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We propose a constrained minimization cost function which enforces the decoder network to mimic the environment dynamics of the agent. The proposed cost function enforces that the decoders model minimizes the loss for dynamics model prediction of next state given the current state and action, whereas the composition of encoder over the decoder minimizes prediction loss of the next state given the current state. This loss function is given as, ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e1c098e6cc132b880454f71b1918a3be9cf3f32e2e9f9448bb44edec1215b820.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { L } _ { p r o p o s e d } = - \\mathbb { E } _ { ( s _ { t } , s _ { t + 1 } ) \\sim \\tau _ { E } } \\bigg ( \\log \\int _ { a } p ( s _ { t + 1 } | s _ { t } , a ; \\theta _ { d y n } ) p ( a | s _ { t } ; \\theta _ { m b } ) d a \\bigg ) } \\\\ & { \\qquad - \\mathbb { E } _ { ( s _ { t } , a _ { t } , s _ { t + 1 } ) \\sim \\tau _ { R L } } \\bigg ( \\log p ( s _ { t + 1 } | s _ { t } , a _ { t } ; \\theta _ { d y n } ) \\bigg ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            253,
+            148,
+            746,
+            210
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where we $\\pmb { \\theta } _ { d y n }$ are the parameters of dynamics model and $\\pmb { \\theta } _ { m b }$ are model-based policy network’s parameters. Let us denote the first term of the loss term in equation 4 as model-based policy loss, $\\mathcal { L } _ { m b }$ and the second term is referred as dynamics model loss, $\\mathcal { L } _ { d y n }$ . As shown in figure 1, we perform alternate minimizations on the proposed cost function and training on the encoder and decoder are performed on two separate datasets. Firstly, the dynamics model parameters are updated from the experience replay samples gathered during model-free exploration. Subsequently, the updated dynamics model is used as the decoder network in the above formulation with fixed weights while the model-based policy parameters are updated by the gradient, $\\nabla _ { \\theta _ { m b } } \\mathcal { L } _ { m b }$ . This enforces the encoder network to act as a model-based policy that learns to predict the optimal action given the current state. During implementations, a deterministic encoder and decoder are used and a single action is sampled from the posterior distribution during training. ",
+        "bbox": [
+            173,
+            217,
+            825,
+            371
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.2.1 LEARNING DYNAMICS MODEL FROM MODEL-FREE SAMPLES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            387,
+            645,
+            400
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Since our expert trajectories only consist of sensory streams containing state information only, learning from the heuristic reward in a MDP setting can be slow and does not guarantee that the reward is optimal for the desired task. Thus we resort to dynamics model based learning which can propagate error gradients with respect to action information as discussed in the above section. Consider an analogy of a robot learning to navigate through a maze of expert state information only. It must first learn the state transition model $p ( \\pmb { s } _ { t + 1 } | \\pmb { s } _ { t } , \\pmb { a } _ { t } )$ to navigate through the environment. Once dynamics model is learned, it can obtain the best action that takes the current state in optimal state trajectories to the next state. Solving for the desired action at each state $\\left( \\boldsymbol { p } ( \\boldsymbol { a } _ { t } | \\boldsymbol { s } _ { t } ) \\right)$ is a maximum likelihood problem from the expert state trajectories which can be solved by end-to-end supervised learning. ",
+        "bbox": [
+            173,
+            410,
+            825,
+            536
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Let us assume we have a parameterized model for agent dynamics, given as $\\pmb { s } _ { t + 1 } = f ( \\pmb { s } _ { t } , \\pmb { a } _ { t } ; \\pmb { \\theta } _ { d y n } )$ , where $\\pmb { \\theta } _ { d y n }$ denotes parameters of the model. During model-free learning, we store the trajectories of $( s _ { t } , a _ { t } , s _ { t + 1 } )$ that were encountered during exploration by the agent. Let us denotes the trajectories of these triplets as $\\tau _ { R L }$ . For continuous state spaces, the gradient for dynamic model parameters are given as ",
+        "bbox": [
+            174,
+            541,
+            825,
+            612
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4078835edd341a91eb8e48312a191fce84edd50ff8cf61b3c9475ea080d5e23c.jpg",
+        "text": "$$\n\\nabla _ { \\theta _ { d y n } } \\mathcal { L } _ { d y n } = \\nabla _ { \\theta _ { d y n } } \\mathbb { E } _ { ( s _ { t } , a _ { t } , s _ { t + 1 } ) \\sim \\tau _ { R L } } \\Big [ \\| f \\big ( s _ { t } , a _ { t } ; \\theta _ { d y n } \\big ) - s _ { t + 1 } \\| _ { 2 } ^ { 2 } \\Big ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            274,
+            628,
+            723,
+            656
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "which is gradient on the mean squared error loss between model predicted and true next state. For the discrete state space case, we can first maximize the probability of next state given the current state and action using a categorical loss. Any standard stochastic gradient descent algorithms can be used for the above optimizations. However, we use neural networks as function approximators which are shown to have approximation capacity for arbitrary non-linear function, although its nonconvex nature of optimization does always guarantee a solution that is globally optimal. Recent techniques in stochastic gradient descent (Zeiler (2012); Kingma & Ba (2014) ) have alleviated this problem to a large extent. ",
+        "bbox": [
+            173,
+            664,
+            825,
+            776
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "If we assume the dynamics model is ideal in predicting the next state and there exists a unique action to reach the next state from the current state, then the proposed method is identical to behavior cloning, although true action information is not provided by the expert. Therefore, the performance of this method is upper bounded by the performance of behavior cloning model which learns from the true action information between states. ",
+        "bbox": [
+            174,
+            782,
+            825,
+            853
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.3 TRANSFORMING STATES BASED ON ACTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            869,
+            516,
+            883
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In our formulation so far, the entire next state of the agent is predicted by the next state predictor. However, we found that predicting a part of the state which is dependent on action gives better reward structure. This is in line with the work of Pathak et al. (2017), where the authors predict $\\phi ( \\pmb { s } _ { t } )$ as the latent representation of the neural network predicting the action from consecutive states, $\\pmb { a } _ { t } = g ( \\phi ( \\pmb { s } _ { t } ) , \\phi ( \\pmb { s } _ { t + 1 } ) )$ . This transformed state value, $\\phi ( \\pmb { s } _ { t } )$ is also used as the input and output for the dynamics model. This transformation is beneficial for two reasons: (i) It is difficult to learn the dynamics model for high dimensional state information and thus first projecting onto a low dimensional manifold to learn the dynamics model gives a more feasible learning framework. (ii) In case of transferring the learned dynamics model between different tasks that use the same environment, a common state input is required for the dynamics model, which can be achieved such transformation. In case of learning from videos, we use the agent position in the image frames as $\\phi ( s _ { t } )$ . For the case of linked arm reacher, we will use $p h i ( s _ { t } )$ as the joint angles and joint velocities. ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            243
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "2.4 ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            271,
+            302,
+            285
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We now outline the algorithm based on the above discussed model-based policy learning framework. ",
+        "bbox": [
+            174,
+            301,
+            823,
+            316
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Model based imitation learning from state trajectories ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            342,
+            616,
+            357
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1: Input : Given expert trajectories $\\tau _ { E }$ , initial parameters $\\theta _ { m b } ^ { 0 } , \\theta _ { m f } ^ { 0 }$ and $\\theta _ { d y n } ^ { 0 }$ and the state transformation $\\phi ( . )$   \n2: Learn next state predictor model $\\begin{array} { r } { \\theta _ { p } \\gets \\arg \\operatorname* { m i n } _ { \\theta _ { p } } - \\mathbb { E } _ { \\{ s _ { 1 : t + 1 } \\} \\sim \\tau _ { E } } \\log p ( \\phi ( s _ { t + 1 } ) | s _ { 1 : t } ; \\theta _ { p } ) } \\end{array}$   \n3: for $k = 1 , 2 , 3 , \\ldots$ do   \n4: Sample trajectory from model-free policy $\\tau _ { k } \\in \\pi _ { m f } ^ { k }$ and add to the replay buffer $\\tau _ { R L }$   \n5: Updated the dynamics model parameter using trajectories from the replay buffer $\\begin{array} { r } { \\theta _ { d y n } ^ { k + 1 } \\gets \\arg \\operatorname* { m i n } _ { \\theta _ { d y n } ^ { k } } - \\mathbb { E } _ { ( s _ { t } , a _ { t } , s _ { t + 1 } ) \\sim \\tau _ { R L } } \\Big ( \\log p ( \\phi ( s _ { t + 1 } ) | \\phi ( s _ { t } ) , a _ { t } ; \\theta _ { d y n } ^ { k } ) \\Big ) } \\end{array}$   \n6: Update model based parameter from expert trajectories with fixed dynamics model. $\\begin{array} { r } { \\theta _ { m b } ^ { k + 1 }  \\mathrm { a r g } \\operatorname* { m i n } _ { \\theta _ { m b } ^ { k } } - \\mathbb { E } _ { ( s _ { t } , s _ { t + 1 } ) \\sim \\tau _ { E } } \\Big ( \\log \\sum _ { a } p ( \\phi ( s _ { t + 1 } ) | \\phi ( s _ { t } ) , a ; \\theta _ { d y n } ^ { k + 1 } ) p ( a | s _ { t } ; \\theta _ { m b } ^ { k } ) \\Big ) } \\end{array}$   \n7: end for ",
+        "bbox": [
+            179,
+            349,
+            823,
+            555
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The above algorithm shows an iterative process where in each iteration we first train a model-free algorithm using the heuristic reward function. This step is necessary because we collect a certain amount of system dynamics data, $( s _ { t } , a _ { t } , s _ { t + 1 } )$ , while training the model-free policy. Then, we train a system dynamics model using the above collected data. The action policy is then trained using the system dynamics model in the model-based part, which constitutes one cycle of the training. Subsequently, we repeat this cycle again starting from the model-free part. With each iteration, we collect additional system dynamics data, which results in a more precise dynamics model, leading to accurate action policy parameter gradients for updating the model-based policy. ",
+        "bbox": [
+            173,
+            582,
+            825,
+            694
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The frequency of switching between model-free replay buffer collection and model-based update can be varied depending on the complexity of dynamics model. For state predictions from previous states, we used Long Short-Term Memory Network, proposed by Hochreiter & Schmidhuber (1997). For the policy and dynamics model, we use neural networks as function approximators. In this work, we assume that the state transformation $\\phi ( . )$ is manually specified in each experiments, although it is possible to learn such representation by learning a common transformation between states that predicts the action, $\\pmb { a } _ { t } = g ( \\bar { \\phi } ( \\pmb { s } _ { t } ) , \\phi ( \\pmb { s } _ { t + 1 } ) )$ . ",
+        "bbox": [
+            173,
+            699,
+            825,
+            799
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            829,
+            415,
+            844
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We perform experimental evaluations on three kinds of environment, (i) Robotics arm reacher in 2d, (ii) Simple 2d obstacle avoidance based reacher, (iii) Learning to play simple games from raw video demonstrations. In each experiment, we show specific strengths of the proposed algorithm as follows. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            922
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/6379de053f41f22153fb46930d318a0004dd4610fb254fceff4719bb5936a40d.jpg",
+        "image_caption": [
+            "Figure 2: (a) Showing the toy obstacle avoidance environment used in our experiments, (b) The directed graphical model, which shows that next is dependent on current state and action, while current action is just dependent of the current state "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            220,
+            101,
+            771,
+            310
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.1 ROBOTICS ARM REACHER IN 2D ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            404,
+            437,
+            417
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We use roboschool reacher(OpenAI (2017); Brockman et al. (2016) environment to simulate twolink robotic arm that can move in two-dimensional space. The desired task is to learn reaching a given target from random starting configurations. The arm is controlled using angular torque values of both joints. We use state values consisting of angular position, angular velocity, the end effector location of the robotic link and the position of the target. The robotic arm angles and angular velocities were used as $\\phi ( \\pmb { s } _ { t } )$ , which is the portion of state dependent on action. In this experiment, we assume that the true reward function is known and in addition, we have some state trajectories from the expert policy. The goal is to leverage these existing state trajectories to learn a better policy in less number of steps. Reward signal, consisting of distance potential, electricity cost and the penalty for stuck joint, which is the default reward specified for the environment, was used. Specifically, we show 500 trajectories of optimal states each with 100 steps to learn model-based policy using the proposed method. We used neural networks with hidden layers containing (128, 64) neurons for both model-based and model-free policies. Training was performed over 2000 episodes using Deep Deterministic Policy Gradients(DDPG) proposed by Lillicrap et al. (2016). ",
+        "bbox": [
+            174,
+            433,
+            825,
+            627
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 3(a) shows the comparison of proposed method against the DDPG algorithm. Our method learns the dynamics model from the model-free exploration, which quickly learns the simple environment dynamics, in this case, thereby learning an optimal policy imitating the state trajectories much faster than model-free training, which is shown in results. However, we found this is due to a large number of state trajectories that are shown to the proposed method. Since our performance is upper bounded by behavior cloning results, we share the same drawbacks of compounding errors and data-hungry policy learning. ",
+        "bbox": [
+            174,
+            633,
+            825,
+            732
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.2 2D OBSTACLE AVOIDER",
+        "text_level": 1,
+        "bbox": [
+            176,
+            756,
+            380,
+            770
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this experiment, we demonstrate that proposed algorithm can be used for direct end-to-end supervised imitation learning on novel tasks without resorting to model-free reinforcement learning. We refer to this setup as one-shot imitation learning, which we demonstrate on a simple toy environment. The environment is shown in figure 2(a). The environment consists of an agent which can freely move in 2D space. The agent is controlled by continuous position control where the action is the change in $( x , y )$ agent position at each time step. The goal is to reach the target location while avoiding the obstacle. Initially, we train our algorithm on an environment to avoid a single obstacle while reaching the target. We use state information as the absolute position of the agent, target and obstacle, the agent velocity and relative location of obstacle and target with respect to the agent. We use $\\phi ( \\pmb { s } _ { t } )$ as the agent 2d position in the environment. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/a7ab005a861fb80546c60fe40dfda21edd68746a9c51640b92400c9b7e917e99.jpg",
+        "image_caption": [
+            "Figure 3: (a) Comparison of proposed method with model-free reinforcement learning methods, behavior cloning and proposed model-based method for Flappy birds. The model-based method is shown to surpass the model-free method in test reward performance with much less iterations, although being upper bounded by behavior cloning results (b) Comparison of the proposed method with continuous model-free methods on roboschool reacher showing better convergence performance with less iterations "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            102,
+            820,
+            328
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For expert demonstration, we implemented a manually engineered policy that always avoids the obstacle. We used 1000 number of demonstrations containing only state trajectories to reach a target while avoiding a single obstacle. Out of 1000 demonstrations, 800 are used for training and 200 for validation. We first learn the time series prediction of the next state, used to compute the heuristic reward based using prediction error as discussed in section 2.1. For model-based policy, we use a MLP with (64, 64) hidden units. We use the same policy network for both model-based and modelfree policy. The dynamics model is also modeled as a neural network with a single hidden layer of 8 units for both state and action input. We used a switching frequency of 5 between the model-free and model-based updates. Using these setting for the proposed algorithm, we get a model-based policy and the dynamics model as output. ",
+        "bbox": [
+            174,
+            457,
+            825,
+            595
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Using the dynamics model obtained from training with demonstrations of single obstacle avoidance, we perform one-shot imitation learning to learn avoidance of two obstacles. The algorithm is presented 500 samples of expert state trajectories for avoiding two obstacles. The model-based policy in the new setting is learned by step 6 of the proposed algorithm 1 using the previously learned dynamics model. Although the state information for the policy networks might change due to an additional obstacle, since $\\phi ( s _ { t } )$ , which is the agent 2d location, remains same in both cases, we can perform one-shot imitation learning in this case. We compare the results with respect to the expert policy and behavior cloning and report the average of test reward on 50 episodes. While the expert policy achieves average test reward of 3036, and behavior cloning achieves 3939 and our imitation learning method gave a reward of 3805. This demonstrates that our proposed algorithm can be used for one-shot imitation in environments with same dynamics and can produce comparable results to behavior cloning which was trained from true actions. ",
+        "bbox": [
+            173,
+            603,
+            825,
+            768
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.3 LEARNING POLICIES FROM RAW VIDEOS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            786,
+            493,
+            800
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this experiment, we learn model-based control policies from raw pixels. We use the python reimplementation of the game Flappy bird (Lau (2017)). In this environment, the agent has to hover through the pipes without collision by flapping its wings. The environment has gravity and with each flap, the agent receives an upward acceleration which sends it to an upward parabolic trajectory. We choose this environment due to its complicated dynamics and show that our proposed method can learn to model this dynamics. We learn action policies from raw videos of just 10 episodes each with 1000 steps. The reward is assumed to be unknown in this case and we estimate the reward by the error in prediction of the next state as mentioned in section 2.1. The control action is a single discrete command of whether to flap the bird’s wings or not. We denotes this action space as $\\{ + 1 , - 1 \\}$ . For state information at each step we use 4 consecutive frames resized to $( 8 0 \\times 8 0 \\times 4 )$ . We also assume that the absolute position of the bird’s location is available to us, which we use as $\\phi ( s _ { t } )$ . This can be also computed by learning a simple object detector from image frames. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For the next state predictor, we use an LSTM predictor that outputs the next position of the agent location given the sequence of states witnessed so far. The model-free reward prediction step receives a reward signal based on the difference of the actual next state taken the policy, from the predicted next state by LSTM. This reward is used to train DQN(Mnih et al. (2015)) for model-free policy update which collects data to train the dynamics model, which in turn trains the model-based policy network. We also train vanilla DQN using a standard reward, which in this case is 0.1 for each time step and $+ 1$ reward if the agent can successfully pass through a pipe. To compare the various methods, we used the reward used by vanilla DQN as a baseline for comparison. ",
+        "bbox": [
+            173,
+            166,
+            825,
+            279
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For the model-based policy we used a convolutional neural network (CNN) with soft-max output, which is essentially a binary classification task. For the DQN model-free policy, the last layer predicts the $\\mathsf { q }$ -values and therefore has linearly activation. In this case, we first learn dynamics model, which is approximated as a multi layered perceptron (MLP) with single hidden layer of 16 units for both state and action inputs. It learns to regress the next state from the current state and actions minimizing mean squared error loss. After this, from the expert demonstration of state trajectory $( \\tau _ { E } )$ , we find the current optimal action that minimizes the next state a∗k = arg mina kp(st+1 − f (st, at)k|at∈{0,1},{st+1,st}∼τE . The next step is to find the modelbased policy by behavior cloning on the states $( \\boldsymbol { s } _ { t } \\sim \\tau _ { E } )$ and current optimal actions, $\\pmb { a } _ { k } ^ { * }$ . We found that, the number of $+ 1 ( \\mathbb { I a p } )$ actions by the agent are far less frequent compared to the number of -1(no flap) actions which cause an unbalance in distribution. Thus, we used class balancing techniques for learning both model based policy update and direct behavior cloning from true actions (baseline) results. ",
+        "bbox": [
+            173,
+            285,
+            825,
+            467
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure 3(b) shows the comparison of proposed model-based method with estimated reward (mb reward pred), behavior cloning $( b c )$ , model-free RL using DQN with standard known reward (dqn reward) and with estimated reward (dqn reward pred). It is to be noted that although original reward just provides a constant reward (of 0.1 and $+ 1$ bonus) without constant guidance at each step value, estimated reward provides a dense guidance signal which leads to faster convergence as shown in the comparison results. We take desired samples from the model-free training, based on prioritized sampling technique with regards to the estimated reward signal, to perform model-based policy update. We found that prioritized sampling was essential to learn a good dynamics model of the environment. The results show that the model-based policy learns behavior close to optimal in much fewer steps compared to the model-free counterparts. However, its performance in upper bounded by the behavior cloning method which achieves an average test reward (over 20 iterations) of 49.62. The expert score is 60.9. Since DQN with estimated reward signal learns via exploration in a MDP setting, it can surpass the performance of behavior cloning since the number of expert demonstrations is limited in this case. ",
+        "bbox": [
+            173,
+            474,
+            825,
+            667
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            694,
+            341,
+            710
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We presented a model-based imitation learning method that can learn to act from expert state trajectories in the absence of action information. Our method uses trajectories sampled from the modelfree policy exploration to train a dynamics model of the environment. As model-free policy is enriched through time, the forward model can better approximate the actual environment dynamics, which leads to improved gradient flow, leading to better model-based policy update which is trained in a supervised fashion from expert state trajectories. In the ideal case, when dynamics model perfectly approximates the environment, our proposed method is equivalent to behavior cloning, even in the absence of action information. We demonstrate that the proposed method learns the desired policy in less number of iterations compared conventional model-free methods. We also show that once the dynamics model is trained it can be used to transfer learning for other tasks in a similar environment in an end-to-end supervised manner. Future work includes tighter integration of the model-based learning and the model-free learning for higher data efficiency by sharing information (1) between the model-free policy $\\pi _ { m f }$ and the model-based policy $\\pi _ { m b }$ and (2) between the next state predictor $p ( s _ { t + 1 } | s _ { t } )$ and the dynamics model $p ( \\pmb { s } _ { t + 1 } | \\pmb { s } _ { t } , \\pmb { a } _ { t } )$ and (3) improving the limitations of compounding errors and requirement of large number of demonstration, by adversarial training which can maximize likelihood of future state distributions as well. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            154,
+            285,
+            167
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nir Baram, Oron Anschel, Itai Caspi, and Shie Mannor. End-to-end differentiable adversarial imitation learning. In Doina Precup and Yee Whye Teh (eds.), Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pp. 390–399, International Convention Centre, Sydney, Australia, 06–11 Aug 2017. PMLR. URL http://proceedings.mlr.press/v70/baram17a.html. ",
+        "bbox": [
+            173,
+            176,
+            825,
+            246
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym, 2016. URL http://gym.openai.com/. ",
+        "bbox": [
+            171,
+            255,
+            823,
+            284
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yan Duan, Marcin Andrychowicz, Bradly Stadie, Jonathan Ho, Jonas Schneider, Ilya Sutskever, Pieter Abbeel, and Wojciech Zaremba. One-shot imitation learning. arXiv preprint arXiv:1703.07326, 2017. ",
+        "bbox": [
+            174,
+            292,
+            823,
+            335
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014. ",
+        "bbox": [
+            171,
+            343,
+            823,
+            387
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Ho and Stefano Ermon. Generative adversarial imitation learning. In Advances in Neural Information Processing Systems, pp. 4565–4573, 2016. ",
+        "bbox": [
+            171,
+            395,
+            823,
+            425
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jrgen Schmidhuber. Long short-term memory. Neural Computation, 9(8): 1735–1780, 1997. doi: 10.1162/neco.1997.9.8.1735. URL https://doi.org/10.1162/ neco.1997.9.8.1735. ",
+        "bbox": [
+            174,
+            433,
+            823,
+            476
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            484,
+            823,
+            513
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In The International Conference on Learning Representations (ICLR), volume abs/1412.6980, USA, 2015. URL http://arxiv.org/abs/1412.6980. ",
+        "bbox": [
+            174,
+            521,
+            821,
+            564
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ben Lau. Keras-flappybird. https://github.com/yanpanlau/Keras-FlappyBird, 2017. ",
+        "bbox": [
+            173,
+            573,
+            823,
+            602
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Timothy Lillicrap, Jonathan Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. In The International Conference on Learning Representations (ICLR), San Juan, Puerto Rico, 2016. URL http://arxiv.org/abs/1509.02971. ",
+        "bbox": [
+            173,
+            609,
+            825,
+            666
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "YuXuan Liu, Abhishek Gupta, Pieter Abbeel, and Sergey Levine. Imitation from observation: Learning to imitate behaviors from raw video via context translation. arXiv preprint arXiv:1707.03374, 2017. ",
+        "bbox": [
+            173,
+            675,
+            823,
+            718
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin Riedmiller, Andreas K. Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, Feb 2015. ISSN 0028-0836. ",
+        "bbox": [
+            174,
+            727,
+            825,
+            796
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew Y. Ng and Stuart J. Russell. Algorithms for inverse reinforcement learning. In Proceedings of the Seventeenth International Conference on Machine Learning, ICML ’00, pp. 663–670, San Francisco, CA, USA, 2000. Morgan Kaufmann Publishers Inc. ISBN 1-55860-707-2. URL http://dl.acm.org/citation.cfm?id=645529.657801. ",
+        "bbox": [
+            174,
+            806,
+            825,
+            863
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "OpenAI. Roboschool. https://github.com/openai/roboschool, 2017. ",
+        "bbox": [
+            173,
+            872,
+            723,
+            887
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Deepak Pathak, Pulkit Agrawal, Alexei A. Efros, and Trevor Darrell. Curiosity-driven exploration by self-supervised prediction. In International Conference on Machine Learning (ICML), 2017. ",
+        "bbox": [
+            171,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dean A Pomerleau. Efficient training of artificial neural networks for autonomous navigation. Neural Computation, 3(1):88–97, 1991. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Danilo J Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In Proceedings of the 31st International Conference on Machine Learning (ICML-14), pp. 1278–1286, 2014. ",
+        "bbox": [
+            173,
+            140,
+            821,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stephane Ross and Drew Bagnell. Efficient reductions for imitation learning. In ´ Proceedings of the thirteenth international conference on artificial intelligence and statistics, pp. 661–668, 2010. ",
+        "bbox": [
+            169,
+            193,
+            823,
+            222
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stephane Ross, Geoffrey J Gordon, and Drew Bagnell. A reduction of imitation learning and struc- ´ tured prediction to no-regret online learning. In International Conference on Artificial Intelligence and Statistics, pp. 627–635, 2011. ",
+        "bbox": [
+            176,
+            229,
+            823,
+            273
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In Proceedings of the 32nd International Conference on Machine Learning (ICML-15), pp. 1889–1897, 2015. ",
+        "bbox": [
+            173,
+            281,
+            823,
+            325
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017. ",
+        "bbox": [
+            171,
+            333,
+            823,
+            363
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction, volume 1. MIT press Cambridge, 1998. ",
+        "bbox": [
+            173,
+            371,
+            823,
+            400
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Richard Stuart Sutton. Temporal credit assignment in reinforcement learning. 1984. ",
+        "bbox": [
+            174,
+            409,
+            727,
+            425
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ziyu Wang, Josh Merel, Scott Reed, Greg Wayne, Nando de Freitas, and Nicolas Heess. Robust imitation of diverse behaviors. arXiv preprint arXiv:1707.02747, 2017. ",
+        "bbox": [
+            173,
+            433,
+            820,
+            462
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matthew D Zeiler. Adadelta: an adaptive learning rate method. arXiv preprint arXiv:1212.5701, 2012. ",
+        "bbox": [
+            173,
+            470,
+            823,
+            501
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Brian D Ziebart, Andrew L Maas, J Andrew Bagnell, and Anind K Dey. Maximum entropy inverse reinforcement learning. In AAAI, volume 8, pp. 1433–1438. Chicago, IL, USA, 2008. ",
+        "bbox": [
+            173,
+            508,
+            825,
+            537
+        ],
+        "page_idx": 10
+    }
+]

parse/train/S1fHmlbCW/S1fHmlbCW.md

@@ -0,0 +1,511 @@
+# NEURAL NETWORKS FOR IRREGULARLY OBSERVED CONTINUOUS-TIME STOCHASTIC PROCESSES
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Designing neural networks for continuous-time stochastic processes is challenging, especially when observations are made irregularly. In this article, we analyze neural networks from a frame theoretic perspective to identify the sufficient conditions that enable smoothly recoverable representations of signals in $L ^ { 2 } ( \mathbb { R } )$ . Moreover, we show that, under certain assumptions, these properties hold even when signals are irregularly observed. As we obtain a family of (convolutional) neural networks that satisfy these conditions, we show that we can optimize our convolution filters while constraining them so that they effectively compute a Discrete Wavelet Transform. Such a neural network can efficiently divide the time-axis of a signal into orthogonal sub-spaces of different temporal scale and localization. We evaluate the resulting neural network on an assortment of synthetic and real-world tasks: parsimonious auto-encoding, video classification, and financial forecasting.
+
+# INTRODUCTION
+
+The predominant assumption made in deep learning for time series analysis is that observations are made regularly, with the same duration of time separating each successive timestamps (Cho et al., 2014; Graves et al., 2013; Sutskever et al., 2014; LeCun & Bengio, 1995; van den Oord et al., 2016; Bakshi & Stephanopoulos, 1993). However, this assumption is often inappropriate, as many real-world time series are observed irregularly and are, occasionally, event-driven (e.g., financial data, social networks, internet-of-things).
+
+One common approach in working with irregularly observed time series is to interpolate the observations to realign them to a regular time-grid. However, interpolation schemes may result in spurious statistical artifacts, as shown in (Huth & Abergel, 2014; Belletti et al., 2017). Fortunately, procedures for working with irregularly observed time series in their unaltered form have been devised, notably in the field of Gaussian-processes and kernel-learning (Huth & Abergel, 2014; Belletti et al., 2017) and more recently in deep learning (Neil et al., 2016).
+
+In this article, we investigate the underlying representation of time series data as it is processed by a neural network. Our objective is to identify a class of neural networks that provably guarantee information preservation for certain irregularly observed signals. In doing so, we must analyze neural networks from a frame theoretic perspective, which has enabled a clear understanding of the impact discrete sampling has on representations of continuous-time signals (Benedetto & Heller, 1990; Benedetto, 1992; Benedetto & Ferreira, 2003; Feichtinger & Gröchenig, 1994; Gröchenig, 1992; Mallat, 2008).
+
+Although frame theory has historically been studied in the linear setting, recent work by Sun & Tang (2017) has related frames with non-linear operators in Banach space, to what can be interpreted as non-linear frames. Here, we extend this generalization of frames to characterize entire families of neural networks. In doing so, we can show that the composition of certain non-linear neural layers (i.e., convolutions and fully-connected layers) form non-linear frames in $L ^ { 2 } ( \mathbb { R } )$ , while others do not (i.e., recurrent layers).
+
+Moreover, frame theory can be used to analyze randomly-observed time series. In particular, when observations are made according to a family of self-exciting point processes known as Hawkes processes (Daley & Vere-Jones, 2007). We prove that such processes, under certain assumptions of stability, almost surely yield non-linear frames on a class of band-limited functions. That is to say, that despite having discrete and irregular observations, the signal of interest can still be smoothly recovered.
+
+As we obtain a family of convolutional neural networks that constitute non-linear frames, we show that under certain conditions, such networks can efficiently divide the time-axis of a time series into orthogonal sub-spaces of different temporal scale and localization. Namely, we optimize the weights of our convolution filters while constraining them so that they effectively compute a Discrete Wavelet Transform (Mallat, 1989). Our numerical experiments on synthetic data highlight this unique capacity that allows neural networks to learn sparse representations of signals in $L ^ { 2 } ( \mathbb { R } )$ , and how such a property is particularly powerful when training parsimoniously parameterized auto-encoders. Such auto-encoders learn optimal ways of compressing certain classes of input signals.
+
+Finally, we show that the ability of these networks to divide time series into a set sub-spaces, corresponding to different temporal scales and localization, can be composed with existing predictive frameworks to improve both accuracy and efficiency. This is demonstrated on real-world video classification and financial forecasting tasks.
+
+# CONTRIBUTIONS & ORGANIZATION
+
+1. Neural representations of $L ^ { 2 } ( \mathbb { R } )$ : We introduce the article with a theoretical analysis of the sufficient conditions on neural networks that enable smoothly recoverable representations of signals in $L ^ { 2 } ( \mathbb { R } )$ and prove that, under certain assumptions, this property holds true in the irregularly observed setting.
+
+2. Orthogonal representations in time: We proceed to show that by enforcing certain constraints on convolutional filters, we can guarantee that the representation that the neural network produces only depends on the coordinates of the input signal in an learned orthonormal basis.
+
+3. Numerical experiments: Finally, we evaluate the resulting constrained convolutional neural network on an assortment of synthetic and real-world tasks: parsimonious auto-encoding, video classification, and financial forecasting.
+
+# NOTATION
+
+• $L ^ { 2 } ( \mathbb { R } )$ is the space of square-integrable real-valued functions defined on $\mathbb { R }$ and equipped with the norm induced by the inner product $\begin{array} { r } { f , g \in L ^ { 2 } ( \mathbb { R } )  \int _ { t \in \mathbb { R } } f ( t ) g ( t ) d t } \end{array}$ . • $L _ { d } ^ { 2 } ( \mathbb { R } )$ is the space of square-integrable d-dimensional vector-valued functions defined on $\mathbb { R }$ and equipped with the norm induced by the inner product $\begin{array} { r } { f , g \in L _ { d } ^ { 2 } ( \mathbb { R } )  \int _ { t \in \mathbb { R } } f ( t ) ^ { T } g ( t ) d t } \end{array}$ • $l ^ { 2 } ( \mathbb { Z } )$ is the space of square-integrable real-valued sequences indexed by $\mathbb { Z }$ and equipped ( )with the norm induced by the inner product $\begin{array} { r } { ( x ) , ( y ) \in \dot { l } ^ { 2 } ( \mathbb { Z } ) \to \sum _ { n \in \mathbb { Z } } x _ { n } \dot { y } _ { n } } \end{array}$ . • $l _ { d } ^ { 2 } ( \mathbb { Z } )$ is the space of square-integrable d-dimensional vector-valued sequences indexed by $\mathbb { Z }$ and equipped with the norm induced by the inner product $\begin{array} { r } { ( x ) , ( y ) \in l _ { d } ^ { 2 } ( \mathbb { Z } )  \sum _ { n \in \mathbb { Z } } x _ { n } ^ { T } y _ { n } } \end{array}$ .
+
+Note that the inner products of the spaces we consider are Hilbert spaces on the classes of equivalent functions for the Lebesgue measure.
+
+• $F T [ \cdot ]$ denotes the Fourier transform and $\overline { z }$ denotes the complex conjugate of $z \in \mathbb { C }$ . Recall the Fourier transform of a sequence $( x _ { n } ) \in \mathbb { Z }$ is given at any frequency $\omega$ by $F T [ ( x _ { n } ) ] ( \omega ) =$ $\begin{array} { r } { \sum _ { n \in \mathbb { Z } } e ^ { - 2 \pi i \omega n } x _ { n } } \end{array}$   
+• For a function $f : t \in \mathbb { R } \to f ( t ) \in \mathbb { R } ^ { d } , f ( \cdot - h )$ is short-hand to denote $f : t \in \mathbb { R } \to f ( t - h ) \in$ $\mathbb { R } ^ { d }$ , likewise, $f ( \cdot / \sigma )$ ∈ is used to denote $f : t \in \mathbb { R } \to f ( t / \sigma ) \in \mathbb { R } ^ { d }$ .   
+• For a set ${ \mathcal { A } } , ( \xi )$ denotes the sequence $( \xi _ { n } ) \in \mathcal { A } ^ { \mathbb { Z } }$ .   
+• $( \xi ) [ : 2 ]$ denotes $( \xi _ { 2 n } ) _ { n \in \mathbb { Z } }$ . That is, the dilation of a sequence by a factor of 2.   
+• For two vectors $\left( w _ { 0 } , w _ { 1 } \right) \in \mathbb { R } ^ { d _ { 1 } } \times \mathbb { R } ^ { d _ { 2 } }$ , their concatenation is denoted by $[ w _ { 0 } , w _ { 1 } ] \in \mathbb { R } ^ { d _ { 1 } + d _ { 2 } }$
+
+We begin by investigating sufficient conditions on composite functions that guarantee such functions produce discretized representations of continuous-time signals that can be smoothly reconstructed.
+
+# 1.1 FRAMES
+
+To do so, we must leverage frame theory (Benedetto & Ferreira, 2003), a theory developed to precisely to characterize the suitable properties for linear representations of irregularly observed signals. Intuitively, a frame is a representation of a signal that enables signal recovery in a smooth manner (i.e., suitable for the representation to be homeomorphic).
+
+Formally (Benedetto & Ferreira, 2003), we define a frame as an operator from $L ^ { 2 } ( \mathbb { R } )$ to $l ^ { 2 } ( \mathbb { Z } )$ that is characterized by a family of functions $( S _ { n } ) _ { n \in \mathbb { Z } }$ in $L ^ { 2 } ( \mathbb { R } )$ ( ) (i.e., the atoms of the frame).
+
+Definition 1.1 Linear frame of $L ^ { 2 } ( \mathbb { R } )$ : $A$ linear operator corresponding to the family $( S ) \ \in$ $L ^ { 2 } ( \mathbb { R } ) ^ { \mathbb { Z } }$ ,
+
+$$
+\mathcal { F } _ { ( S ) } : f \in L ^ { 2 } ( \mathbb { R } ) \to ( < f , S _ { n } > ) _ { n \in \mathbb { Z } } \in l ^ { 2 } ( \mathbb { Z } )
+$$
+
+is a frame of $L ^ { 2 } ( \mathbb { R } )$ if and only if there exist two real-valued constants $0 < A \leq B$ such that
+
+$$
+\forall f \in L ^ { 2 } ( \mathbb { R } ) , A \| f \| _ { 2 } ^ { 2 } \leq \| { \mathcal { F } } _ { ( S ) } ( f ) \| _ { 2 } ^ { 2 } \leq B \| f \| _ { 2 } ^ { 2 } .
+$$
+
+Representations provided by frames depend smoothly on their inputs. Moreover, a direct consequence of the definition above is that a frame is invertible in a smooth manner on its image.
+
+There are many examples of frames. For now, we provide two concrete examples from (Benedetto   
+& Ferreira, 2003; Mallat, 2008). Recall the definition of the Haar function as $t \in \mathbb { R }  W _ { \mathrm { H a a r } } ( t ) =$ $t \in [ 0 , 1 / 2 )$ $^ { - 1 }$ f c $t \in \left[ 1 / 2 , 1 \right)$ , 0 otherwa frame of set of dilations and translations of . Shannon’s sampling theorem sh $W _ { \mathrm { H a a r } }$ , namelyhat, with   
+$\left( W _ { \mathrm { H a a r } } \left( \frac { \mathrel { \mathop { : } } - 2 ^ { l } t } { 2 ^ { l } } \right) \right) _ { t , l \in \mathbb { Z } }$ $L ^ { 2 } ( \mathbb { R } )$   
+sampling frequency $\frac { 1 } { \Delta t }$ , the set of translated functions $( \sqrt { \Delta t } \frac { \sin ( \pi ( t - n ) / \Delta t ) } { \pi t } ) _ { n \in \mathbb { Z } }$ is also a frame for   
+the set of functions in $L ^ { 2 } ( \mathbb { R } )$ ( πt )  whose Fourier transforms are supported on the interval $\begin{array} { r } { \left[ - \frac { 1 } { \Delta t } , \frac { 1 } { \Delta t } \right] } \end{array}$ . In   
+both cases, the atoms of the frame are orthonormal families of functions – it is trivial to prove that $A = B = 1$ . While the first frame works for the entire space of square integrable functions, the second   
+only applies to the sub-space of band-limited signals.
+
+Proposition 1.1 Left inverses of Frames: If $\mathcal { F } _ { ( S ) }$ is a frame of $L ^ { 2 } ( \mathbb { R } )$ then $\mathcal { F } _ { ( S ) }$ has a left inverse $\mathcal { F } ^ { + } = ( \mathcal { F } _ { ( S ) } ^ { * } \mathcal { F } _ { ( S ) } ) ^ { - 1 } \mathcal { F } _ { ( S ) } ^ { * }$ that is $\scriptstyle { \frac { 1 } { \sqrt { A } } }$ Lipschitz, where $\mathcal { F } _ { ( S ) } ^ { * }$ is the adjoint of $\mathcal { F } _ { ( S ) }$ .
+
+This fundamental proposition is proven in (Benedetto & Ferreira, 2003; Mallat, 2008). As our goal is to find the conditions for non-linear representations of $L ^ { 2 } ( \mathbb { R } )$ to be homeomorphic, we unfortunately can not leverage properties in the linear setting. Therefore, we must adopt an alternative definition. Let a non-linear frame be an operator from $\breve { L } ^ { 2 } ( \mathbb { R } )$ to $l ^ { 2 } ( \mathbb { Z } )$ that is characterized by a family of functions $( S _ { n } ) _ { n \in \mathbb { Z } }$ in $L ^ { 2 } ( \mathbb { R } )$ and a family of non-linear real valued functions $( \psi _ { n } ) _ { n \in \mathbb { Z } }$ defined over $\mathbb { R }$ (or $\mathbb { R } ^ { d }$ as a trivial extension).
+
+Definition 1.2 Non-linear frame of $L ^ { 2 } ( \mathbb { R } )$ : A non-linear discrete representation scheme
+
+$$
+\mathcal F _ { ( S ) , ( \psi ) } : f \in L ^ { 2 } ( \mathbb { R } ) \to \big ( \psi _ { n } ( < f , S _ { n } > ) \big ) _ { n } \in l ^ { 2 } ( \mathbb { Z } )
+$$
+
+is a non-linear frame of $L ^ { 2 } ( \mathbb { R } )$ if there exist two real-valued constants $0 < A \leq B$ such that
+
+$$
+\forall f , g \in L ^ { 2 } ( \mathbb { R } ) , A \Vert f - g \Vert _ { 2 } ^ { 2 } \leq \Vert \mathcal { F } _ { ( S ) , ( \psi ) } ( f ) - \mathcal { F } _ { ( S ) , ( \psi ) } ( g ) \Vert _ { 2 } ^ { 2 } \leq B \Vert f - g \Vert _ { 2 } ^ { 2 } .
+$$
+
+It is worth noting that a linear frame (in the standard definition of the term) is still a frame in this non-linear setting.
+
+Proposition 1.2 Smoothness of signal recovery: A non-linear frame is invertible on its image of $L ^ { 2 } ( { \bar { \mathbb { R } } } )$ and the inverse is $\textstyle { \frac { 1 } { \sqrt { A } } }$ Lipschitz.
+
+Proof 1.1 Consider $f , g \in L ^ { 2 } ( \mathbb { R } )$ such that $\mathcal { F } _ { ( S ) , ( \psi ) } ( \boldsymbol { f } ) = \mathcal { F } _ { ( S ) , ( \psi ) } ( \boldsymbol { g } )$ , then, as $A > 0$ , $\| f - g \| _ { 2 } = 0$ and therefore $f$ and $g$ are in same equivalence class in $L ^ { 2 } ( \mathbb { R } )$ . Therefore, $\mathcal { F } _ { ( S ) , ( \psi ) }$ is injective and if we consider $( x ) , ( y ) \in \mathcal { F } _ { ( S ) , ( \psi ) } ( L ^ { 2 } ( \mathbb { R } ) )$ and if we denote by $f _ { x }$ the only element in $L ^ { 2 } ( \mathbb { R } )$ such that $\mathcal { F } _ { ( S ) , ( \psi ) } ( f _ { x } ) = ( x )$ , and $f _ { y }$ the only element in $L ^ { 2 } ( \mathbb { R } )$ such that $\mathcal { F } _ { ( S ) , ( \psi ) } ( f _ { y } ) = \big ( y )$ then, by definition of a non-linear frame, $\begin{array} { r } { \| f _ { x } - f _ { y } \| _ { 2 } ^ { 2 } \leq \frac { 1 } { A } \| x - y \| _ { 2 } ^ { 2 } } \end{array}$ .
+
+In a later section, we will show that smooth signal recovery is crucial for non-linear signal approximations (consisting of a finite number of coefficients) to remain stable during reconstruction. However in order to show this, we must first explore the sufficient conditions on non-linear operators to produce non-linear frames. We start by introducing several definitions on multivariate real-valued functions.
+
+Definition 1.3 Bi-Lipschitz-Invertible $( B L I )$ operators: An operator $\Phi : l ^ { 2 } ( \mathbb { Z } ) \to l ^ { 2 } ( \mathbb { Z } )$ such that
+
+$$
+\exists 0 < A < B s . t . \forall ( x _ { n } ) , ( y _ { n } ) \in L ^ { 2 } ( \mathbb { Z } ) , A | | x - y | | _ { 2 } ^ { 2 } \leq | | \Phi ( x ) - \Phi ( y ) | | _ { 2 } ^ { 2 } \leq B | | x - y | | _ { 2 } ^ { 2 } ,
+$$
+
+is a BLI operator and we refer to $( A , B )$ as some framing constants of $\Phi$ .
+
+Theorem 1.1 BLI operators and linear frames: Let $( \Phi _ { l } ) _ { l = 1 \dots L }$ be a collection of BLI operators with framing constants $( ( A _ { l } , B _ { l } ) ) _ { l = 1 \dots L }$ and $\mathcal { F }$ a frame on $L ^ { 2 } ( \mathbb { R } )$ with framing constants $A _ { 0 }$ and $B _ { 0 }$ . The composite operator $\phi _ { L } \circ \cdots \circ \phi _ { 1 } \circ { \mathcal { F } }$ is a non-linear frame of $L _ { 2 } ( \mathbb { R } )$ with framing constants $\textstyle \prod _ { l = 0 } ^ { L } A _ { 0 }$ and $\textstyle \prod _ { l = 0 } ^ { L } B _ { 0 }$ .
+
+Proof 1.2 The proof of the theorem is immediate but we use it to expose how our careful choice of the definition of non-linear frames is leveraged. First let us recall that injectivity is preserved by composition. Then, we initiate an immediate proof by induction with a simple remark: consider two functions $f , g \in L ^ { 2 } ( \mathbb { R } )$
+
+$$
+\begin{array} { r l } & { A _ { 1 } A _ { 0 } \| \boldsymbol { f } - \boldsymbol { g } \| _ { 2 } ^ { 2 } \leq A _ { 1 } \| \mathcal { F } ( \boldsymbol { f } ) - \mathcal { F } ( \boldsymbol { g } ) \| ^ { 2 } } \\ & { \qquad \leq B _ { 1 } \| \mathcal { F } ( \boldsymbol { f } ) - \mathcal { F } ( \boldsymbol { g } ) \| _ { 2 } ^ { 2 } } \\ & { \qquad \leq B _ { 1 } B _ { 0 } \| \boldsymbol { f } - \boldsymbol { g } \| _ { 2 } ^ { 2 } } \end{array}
+$$
+
+To conclude the proof, a similar statement can then be made if we compose $\Phi _ { 1 } \circ { \mathcal { F } }$ by $\Phi _ { 2 } , \ldots \Phi _ { L }$ .
+
+This proof allows us to make guarantees about operator pipelines while relying on conditions that are simple to verify. We can now use the theory we have established to analyze the representational properties of neural networks; in particular, convolutional neural networks (CNN) and recurrent neural networks (RNN).
+
+# 1.2 SUFFICIENT CONDITIONS ON CNNS TO PRODUCE NON-LINEAR FRAMES
+
+Here, we study representational properties of recent CNN architectures (Chollet, 2016; Kaiser et al., 2017; Lebedev et al., 2014) that rely on depth-wise separable convolutions. We show that by enforcing certain constraints on the structure of temporal filters, we obtain a network that is, provably, a non-linear frame. Here we trade off expressiveness for representational guarantees as we impose constraints on network parameters.
+
+In depth-wise separated convolution stacks (Chollet, 2016; Kaiser et al., 2017) a temporal convolution is applied before a depth-wise linear transform and finally a leaky ReLU layer. We assume that the depth-wise linear operators being learned are all full rank (or full column rank if they increase the number of dimensions of the representation). Such an assumption makes sense for CNNs being trained by a stochastic optimization method with non-pathological data-sets.
+
+Inspired by the multi-scale parsing enabled by the discrete wavelet transform or dyadic wavelet transform we employ time domain convolutions that are conjugate mirror filters (Mallat, 2008). Such time domain filters constitute a decomposition filter bank consisting of cascading convolutions. The decomposition filter bank admits a dual reconstruction filter bank thereby guaranteeing injectivity.
+
+Definition 1.4 Element-wise Leaky ReLU (LReLU): Consider $0 < \alpha < < 1$ , LReLU applies a piecewise linear function element-wise as
+
+$$
+L R e L U _ { \alpha } \colon ( x _ { n } ) \in l _ { d } ^ { 2 } ( \mathbb { Z } ) \to ( \operatorname* { m a x } ( \alpha x _ { n } , x _ { n } ) ) _ { n \in \mathbb { Z } } \in l _ { d } ^ { 2 } ( \mathbb { Z } ) .
+$$
+
+Definition 1.5 Depth-wise fully connected layer (DFC): Consider two integers $d _ { i }$ and $d _ { o }$ , $A \ \in$ $\mathbb { R } ^ { d _ { o } , d _ { i } }$ and $b \in \mathbb { R } ^ { d _ { o } }$
+
+$$
+D F C _ { A , b } : \ ( x _ { n } ) \in l _ { d _ { i } } ^ { 2 } ( \mathbb { Z } )  ( L R e L U ( A \times x _ { n } + b ) ) _ { n \in \mathbb { Z } } \in l _ { d _ { o } } ^ { 2 } ( \mathbb { Z } ) .
+$$
+
+Lemma 1.1 Full column rank DFC (FDFC) layers are BLI: The function
+
+$$
+w \in \mathbb { R } ^ { d _ { i } } \to L R e L U ( A w + b ) \in \mathbb { R } ^ { d _ { o } }
+$$
+
+with $d _ { i } \ \leq \ d _ { o }$ and $A$ is full column rank is left invertible. Also, the left inverse is Lipschitz as $\exists 0 < m \leq M \in \mathbb { R }$ such that
+
+$$
+\forall w \in \mathbb { R } _ { i } ^ { d } , m | | w - w ^ { \prime } | | ^ { 2 } \leq \| L R e L U \big ( A w + b \big ) - L R e L U \big ( A w ^ { \prime } + b \big ) \| ^ { 2 } \leq M \| w - w ^ { \prime } \| ^ { 2 } .
+$$
+
+Proof 1.3 As LReLU is strictly increasing and continuous therefore it is invertible and as $A$ is full column rank it admits a left inverse which proves the first part of the lemma. We finish the proof by using the fact that linear functions in vector spaces of finite dimensions are Lipschitz, the fact that LReLU and its inverse are Lipschitz, and the fact that Lipschitz-ness is preserved by composition.
+
+Let us now study the representational properties of time domain convolution layers whose filters are constrained in the Frequency domain.
+
+Definition 1.6 Reconstructible convolution layer (RConv): Consider two convolution filters $h , g \in$ $l ^ { 2 } ( \mathbb { Z } )$ such that there exist $\widetilde { h } , \widetilde { g } \in l ^ { 2 } ( \mathbb { Z } )$ and
+
+$$
+\forall \omega \in \mathbb { R } , F T [ \widetilde { h } ] \times \overline { { F T [ h ] } } ( \omega ) + F T [ \widetilde { g } ] \times \overline { { F T [ g ] } } ] ( \omega ) = 2 .
+$$
+
+The following convolution is a Reconstructible convolution layer:
+
+$$
+R C o n v _ { l , h , g } : \ ( x _ { n } ) \in l _ { d } ^ { 2 } ( \mathbb { Z } )  ( [ h * x _ { n } , g * x _ { n } ] ) _ { n \in \mathbb { Z } } \in l _ { 2 \times d } ^ { 2 } ( \mathbb { Z } ) .
+$$
+
+Later on, we show that entire families of such $\widetilde { h } , \widetilde { g } \in l ^ { 2 } ( \mathbb { Z } )$ exist under some conditions on $h , g$ . In particular Eq. (4) will provide simple sufficient conditions on $h$ and $g$ for Eq. (1) to hold.
+
+Lemma 1.2 Temporal convolutions allowing reconstruction: Consider four temporal convolution filters $h , \tilde { h } , g , \tilde { g }$ such that their Fourier transforms satisfy (1). If $\cdot _ { x _ { l + 1 } ^ { 0 } } = h * x _ { l }$ and $x _ { l + 1 } ^ { 1 } = g * x _ { l }$ then $x _ { l } = \textstyle \frac { 1 } { 2 } \left( \widetilde { h } \bigl [ \because - 1 \bigr ] * x _ { l + 1 } ^ { 0 } + \widetilde { g } \bigl [ \mathrel { \mathop : } \because - 1 \bigr ] * x _ { l + 1 } ^ { 1 } \right)$ (where $[ : : - 1 ]$ means that we iterate in reverse order on the =  ( [∶∶ − ] ∗ + ̃[∶∶ − ] ∗ ) [∶∶ − ]filter weights) which proves the pair of convolution filters constitutes an invertible operator. Also, $\exists 0 < m \leq M$ such that
+
+$$
+m \| x _ { l } \| _ { 2 } ^ { 2 } \leq \| x _ { l + 1 } ^ { 0 } \| _ { 2 } ^ { 2 } + \| x _ { l + 1 } ^ { 1 } \| _ { 2 } ^ { 2 } \leq M \| x _ { l } \| _ { 2 } ^ { 2 } .
+$$
+
+Proof 1.4 By definition $\widetilde { h } \big [ : : - 1 \big ] \ast x _ { l + 1 } ^ { 0 } + \widetilde { g } \big [ : : - 1 \big ] \ast x _ { l + 1 } ^ { 1 } = \widetilde { h } \big [ : : - 1 \big ] \ast h \ast x ^ { l } + \widetilde { g } \big [ : : - 1 \big ] \ast g \ast x ^ { l }$ , therefore, if we recall that the Fourier Transform diagonalizes convolutions and turns time reversal into complex conjugacy, we have
+
+F T $\left[ \widetilde { h } \left[ : : - 1 \right] \ast x _ { l + 1 } ^ { 0 } + \widetilde { g } \left[ : : - 1 \right] \ast x _ { l + 1 } ^ { 1 } \right] = \left( F T \left[ \widetilde { h } \right] \times F T \left[ h \right] + \overline { { F T \left[ \widetilde { g } \right] } } \times F T \left[ g \right] \right) \times F T \left[ x ^ { l } \right] = 2 F T \left[ x ^ { l } \right]$ with condition (1). Also with the Plancherel formula $\Vert h \ast x ^ { l } \Vert _ { 2 } ^ { 2 } = \Vert F T [ h \ast x ^ { l } ] \Vert _ { 2 } ^ { 2 } \leq \Vert F T [ h ] \Vert _ { 2 } ^ { 2 } \times$ $\Vert F T [ x ^ { l } ] \Vert _ { 2 } ^ { 2 } = \Vert h \Vert _ { 2 } ^ { 2 } \Vert x ^ { l } \Vert _ { 2 } ^ { 2 }$ . And finally, $\begin{array} { r } { \| \boldsymbol { F T } [ \boldsymbol { x } ^ { l } ] \| _ { 2 } ^ { 2 } = \frac { 1 } { 4 } \| \boldsymbol { F T } [ \widetilde { h } [ : : - 1 ] \ast x _ { l + 1 } ^ { 0 } + \widetilde { g } [ : - 1 ] \ast x _ { l + 1 } ^ { 1 } ] \| _ { 2 } ^ { 2 } \leq } \end{array}$ $\begin{array} { r } { \frac { 1 } { 4 } \left( \lVert F T [ \widetilde { h } [ : : - 1 ] * x _ { l + 1 } ^ { 0 } \rVert _ { 2 } ^ { 2 } + \lVert F T [ \widetilde { g } [ : : - 1 ] * x _ { l + 1 } ^ { 1 } ] \rVert _ { 2 } ^ { 2 } \right) } \end{array}$ which concludes the proof with
+
+$$
+m = \frac { | | \widetilde { h } | | _ { 2 } ^ { 2 } + | | \widetilde { g } | | _ { 2 } ^ { 2 } } { 4 } a n d M = | | h | | _ { 2 } ^ { 2 } + | | g | | _ { 2 } ^ { 2 } . \mathbf { 1 }
+$$
+
+We represent the recomposition operation introduced in Lemma 1.2 in . The next proposition shows how the convolutions RConv and non-linearity LReLU can be interleaved to produce non-linear frames.
+
+# Proposition 1.3 Compositions of FDFC and RConv layers are BLI: The composite function from $l _ { d _ { i } } ^ { 2 } ( \mathbb { Z } )$ onto $l _ { d _ { o } } ^ { 2 } ( \mathbb { Z } )$
+
+$$
+F D F C _ { A _ { L } , b _ { L } } \circ R C o n v _ { L , h _ { l } , g _ { l } } \circ \cdots \circ F D F C _ { A _ { 1 } , b _ { 1 } } \circ R C o n v _ { 1 , h _ { 1 } , g _ { 1 } }
+$$
+
+is BLI.
+
+![](images/01b3a6d27d0e2e133a48ba06f5945ef14c22d25ba149b20bdbff7f5f69e773c5.jpg)  
+Figure 1: Decomposition and recomposition principle for depth-wise separable convolutions. We denote the Moore-Penrose inverse of the full column rank matrix $A$ by $A ^ { + }$ .
+
+Proof 1.5 Let us recall again that injectivity is stable by composition of operators. It is also clear that non-linear framing conditions remain true as composite bi-Lipschitz functions are also bi-Lipschitz.
+
+With the proposition above it is now trivial to prove the theorem below.
+
+Theorem 1.2 Compositions of FDFC and dilated RConv layers are non-linear frame: If $\mathcal { F }$ is $a$ frame of $L ^ { 2 } ( \mathbb { R } )$ then the composite function from $L _ { d _ { i } } ^ { 2 } ( \mathbb { R } )$ onto $l _ { d _ { o } } ^ { 2 } ( \mathbb { Z } )$
+
+$$
+F D F C _ { A _ { L } , b _ { L } } \circ R C o n v _ { L , h _ { L } , g _ { L } } \circ \cdots \circ F D F C _ { A _ { 1 } , b _ { 1 } } \circ R C o n v _ { 1 , h _ { 1 } , g _ { 1 } } \circ \mathcal { F }
+$$
+
+is a non-linear frame.
+
+Now, we expose the framing properties of RNNs (for an introduction on RNNs we refer the reader to (Bengio et al., 1994)). For the vast majority of popular recurrent architectures (for instance, LSTMs, GRUs (Hochreiter & Schmidhuber, 1997; Cho et al., 2014)) the use of bounded output layers leads to saturation and vanishing gradients. With such vanishing gradients Bengio et al. (1993), it is possible to find series of input sequences that diverge in $l ^ { 2 } ( \mathbb { Z } )$ while their outputs through the RNN are a Cauchy sequence.
+
+Proposition 1.4 Saturating RNNs do not provide non-linear frames: Let us consider a RNN
+
+$$
+\mathcal { F } _ { ( S ) , ( \psi ) } : f \in L ^ { 2 } ( \mathbb { R } ) \to \big ( \psi _ { n } \big ( \big ( < f , S _ { n ^ { \prime } } > \big ) _ { n ^ { \prime } \in \mathbb { Z } } \big ) \big ) _ { n } \in l ^ { 2 } ( \mathbb { Z } )
+$$
+
+where $\mathcal { F } _ { ( S ) }$ is a given linear frame of $L ^ { 2 } ( \mathbb { R } )$ . If there exists a sequence $( v ^ { k } ) _ { k \in \mathbb { Z } } \in \mathcal { F } _ { ( S ) } ( L ^ { 2 } ( \mathbb { R } ) ) ^ { \mathbb { Z } }$ such that $( ( \psi _ { n } ( v ^ { k } ) ) _ { n \in \mathbb { Z } } ) _ { k \in \mathbb { N } }$ is a Cauchy sequence in $l ^ { 2 } ( \mathbb { Z } )$ while $\| v ^ { k } \| _ { 2 } \to + \infty$ , then $\mathcal { F } _ { ( S ) , ( \psi ) }$ is not ((a linear frame.
+
+Proof 1.6 With the assumption on $( v ^ { k } ) _ { k \in \mathbb { Z } } \in \mathcal { F } _ { ( S ) } ( L ^ { 2 } ( \mathbb { R } ) ) ^ { \mathbb { Z } }$ , there cannot exist $A > 0$ such that
+
+$\forall k _ { 0 } , k _ { 1 } \in \mathbb { Z } , A \lVert v ^ { k _ { 0 } } - v ^ { k _ { 1 } } \rVert _ { 2 } ^ { 2 } \leq \lVert \big ( \psi _ { n } \big ( \big ( < v ^ { k _ { 0 } } , S _ { n ^ { \prime } } > \big ) _ { n ^ { \prime } \in \mathbb { Z } } \big ) \big ) _ { n \in \mathbb { Z } } - \big ( \psi _ { n } \big ( \big ( < v ^ { k _ { 1 } } , S _ { n ^ { \prime } } > \big ) _ { n ^ { \prime } \in \mathbb { Z } } \big ) \big ) _ { n \in \mathbb { Z } } \rVert _ { 2 } ^ { 2 }$ as the sequence $( v ^ { k } )$ would then be Cauchy and therefore converge as $l ^ { 2 } ( \mathbb { Z } )$ is complete for the $l ^ { 2 }$ norm.
+
+Such a proposition highlights a key difference between the representational ability of RNNs and CNNs. We explore representations of irregularly sampled data through the lens of non-linear frames.
+
+# 1.3 IRREGULAR SAMPLING
+
+We now show that even when signals are irregularly observed by a random sampling process, that particular neural networks can still, almost surely produce a homeomorphic representation.
+
+Sampling by Hawkes processes is a common assumption in finance, seismology, and social media analytics (Ogata, 1988; Bacry et al., 2015; Belletti et al., 2017; Yang & Zha, 2013; Li & Zha, 2013; Zhao et al., 2015). We use $\dot { ( } \mathcal { T } _ { t } ^ { N } )$ to denote the canonical filtration associated with the stochastic process $( N _ { t } ) _ { t \in \mathbb { R } }$ (I ). We recommend (Daley & Vere-Jones, 2007) for a more thorough introduction to this concept. As a simplification, we denote $\mathcal { T } _ { t } ^ { N }$ to be the information generated by $( N _ { s } ) _ { s < t }$ .
+
+Definition 1.7 Random sampling Hawkes process: A stochastic point process $( N _ { t } )$ (Daley & VereJones, 2007) defines a random measure over the axis of time and is defined by stochastic local Poisson intensities for $( N _ { t } )$
+
+$$
+\lambda _ { t } = l i m _ { d t  0 + } \frac { E [ N ( t + d t ) - N ( t ) | T _ { t } ^ { N } ] } { d t } .
+$$
+
+For a Hawkes process characterized by $\phi : t \in \mathbb { R } \to \phi ( t ) \geq 0 , \forall t < 0 , \phi ( t ) = 0 , \mu \geq 0$ , we assume
+
+$$
+\lambda _ { t } = \mu + \phi * d N _ { t } .
+$$
+
+In other words, $\lambda _ { t }$ is the number of observations per unit of time expected given the events that occurred until time $t$ . Intuitively, if $\lambda _ { t }$ is higher, then it is more likely for observations to be available shortly after the time $t$ .
+
+As in (Belletti et al., 2017; Bacry et al., 2015), Hawkes processes can be used to model the random observation time of a continuous-time series in a setting where information is observed asynchronously in an event-driven manner across multiple channels (the extension to multi-variate point processes is immediate).
+
+Proposition 1.5 Sampling density of stable Hawkes processes: If the Hawkes process (2) is stable (i.e. $\textstyle \mathbf { \bar { \rho } } _ { f \in \mathbb { R } } \phi ( t ) d t < 1 )$ , then almost surely
+
+$$
+\operatorname* { l i m } _ { t \to + \infty } \frac { N _ { t } } { t } = \frac { \mu } { 1 - \int _ { t \in \mathbb { R } } \phi ( t ) d t } .
+$$
+
+A complete proof of the ergodic behavior of stable Hawkes processes is provided in (Daley & Vere-Jones, 2007). Now, given an asymptotic Nyquist sampling rate for a random sampling scheme, the following lemma delineates which frames can still be used for signal recovery. In particular, we can no longer recover all signals in an unambiguous manner. Hence, exact recovery is only possible for band-limited functions (i.e. functions whose Fourier transform has bounded support).
+
+Theorem 1.3 Irregular sampling frames: If a sequence of time-stamps have the property that
+
+$$
+\operatorname* { l i m } _ { n  \pm \infty } t _ { n } = \pm \infty a n d \operatorname* { l i m } _ { n  + \infty } \frac { n } { t _ { n } } > 2 R _ { 1 } ,
+$$
+
+then $\left( e ^ { - 2 i t _ { n } \cdot } \right)$ is a frame $\mathcal { F }$ of $L ^ { 2 } [ - R , R ]$ (where the real axis represents sampling frequencies) with (left inverse ${ \mathcal { F } } ^ { + }$ F. Considering $R < R _ { 1 }$ ]and $S \in L ^ { 2 } ( \mathbb { R } )$ such that
+
+$$
+| | F T [ S ] | | _ { \infty } < + \infty , s u p p o r t ( F T [ S ] ) \subset [ - R _ { 1 } , R _ { 1 } ] a n d \forall \omega \in [ - R , R ] , F T [ S ] ( \omega ) = 1 ,
+$$
+
+then
+
+$$
+\begin{array} { r l } & { \forall f \in L ^ { 2 } ( \mathbb { R } ) s . t . ~ s u p p o r t ( F T [ f ] ) \subset [ - R , R ] , f = \sum x _ { n } ( f ) S ( \cdot - t _ { n } ) } \\ & { \mathsf { r } _ { n } ( f ) = \int _ { \omega = - R _ { 1 } } ^ { R _ { 1 } } \mathcal { F } ^ { + } \big ( F T [ f ] 1 _ { [ - R _ { 1 } , R _ { 1 } ] } ) ( \omega ) e ^ { 2 i t _ { n } \omega } d \omega . } \end{array}
+$$
+
+Complete proof is given in (Benedetto & Heller, 1990; Benedetto, 1992); the theorem is regarded as the fundamental theorem of frame analysis for irregularly observed signals. We now leverage the fundamental properties that were obtained in the deterministic setting and extend them to provide guarantees under random sampling schemes.
+
+Proposition 1.6 Under Hawkes process random sampling, framing is preserved almost surely: Let $( t _ { n } ) _ { n \in \mathbb { Z } }$ be a family of sampling time-stamps generated by a stable Hawkes process whose intensity follows the dynamics described in (2), denote
+
+$$
+R = \frac { 1 } { 2 } \frac { \mu } { 1 - \int _ { t \in \mathbb { R } } \phi ( t ) d t } ,
+$$
+
+and let $S$ be a frame operator abiding by conditions (3), then almost surely the frame is injective on $\left\{ f \in L ^ { 2 } ( \mathbb { R } ) \right.$ s.t. suppor $\mathsf { \Omega } ^ { \prime } ( F T [ f ] ) \subset [ \bar { - R } , R ] \}$ when translated by the irregular time-stamps $( t _ { n } ) _ { n \in \mathbb { Z } }$
+
+Proof 1.7 The proposition is a direct consequence of Prop. 1.5 and Theorem 1.3.
+
+Theorem 1.4 Recovery of randomly observed band-limited signals: Let $( t _ { n } ) _ { n \in \mathbb { Z } }$ be a family of sampling time-stamps generated by a stable Hawkes process whose intensity follows the dynamics described in (2) Consider $\begin{array} { r } { R = \frac { 1 } { 2 } \frac { \overline { { \mu } } } { 1 - \int _ { t \in \mathbb { R } } \phi ( t ) d t } } \end{array}$ , let $\mathcal { F } _ { ( S ) }$ be a frame operator with atoms $( S ( \cdot - t _ { n } ) ) _ { n \in \mathbb { Z } }$ given by (3). A composite function from $L _ { d _ { i } } ^ { 2 } ( \mathbb { R } )$ onto $l _ { d _ { o } } ^ { 2 } ( \mathbb { Z } )$
+
+$$
+F D F C _ { A _ { L } , b _ { L } } \circ R C o n v _ { L , h _ { L } , g _ { L } } \circ \cdots \circ F D F C _ { A _ { 1 } , b _ { 1 } } \circ R C o n v _ { 1 , h _ { 1 } , g _ { 1 } } \circ \mathcal { F } _ { ( S ( \cdot - t _ { n } ) ) _ { n \in \mathbb { Z } } }
+$$
+
+is almost surely a non-linear frame over the set of functions in $L ^ { 2 } ( \mathbb { R } )$ whose Fourier Transform has its support included in $[ - R , R ]$ . In particular such a representation is invertible on its image by $a$ Lipschitz inverse.
+
+Proof 1.8 Previously, we proved Theorem 1.2 on the preservation of framing properties by composition with FDFC and RConv layers. In Prop. 1.6 we proved that $\mathcal { F } _ { ( S ( \cdot - t _ { n } ) ) _ { n \in \mathbb { Z } } }$ is almost surely a frame of the subset of $L ^ { 2 } ( \mathbb { R } )$ of functions with band-limit $[ - R , R ]$ .
+
+One concern, however, is that the theorems we developed assumed observations on the entire real axis are available as well as infinite representations indexed by $\mathbb { Z }$ . In particular, a theory of framing for band-limited functions is useful but only applies to periodic functions. Bounded support function of $L ^ { 2 } ( \mathbb { R } )$ are part of the many examples that are not band-limited Mallat (2008); Benedetto & Ferreira (2003).
+
+# 1.4 FINITE APPROXIMATIONS OF NON BAND-LIMITED SIGNALS
+
+In our objective to develop theoretical statements that can be leveraged in practice (i.e., when computing with finite time and memory), we must now extend our analysis to (1) functions observed on compact intervals and (2) finite approximations of signals. The following statements show how the requirements of Lipschitz-ness in non-linear frames provide guarantees on the impact of approximation errors associated with finite representation of continuous-time signals.
+
+The theorems above can be employed for irregularly observed functions that are periodic and band-limited (Benedetto & Ferreira, 2003; Benedetto, 1992; Mallat, 2008). However, since we hope to develop a representational theory that is applicable to non-stationary signals, we must also consider non-periodic functions. In the appendix, we show how wavelet decomposition can efficiently approximate certain classes of functions that are smooth and not band-limited.
+
+With $\lfloor \log _ { 2 } ( N ) \rfloor$ scales of decomposition and $O ( N )$ scalars representing the approximation of $f$ as P⌊log2(N)⌋W f the Wavelet approximation error is O 2−Nα in L2 norm for the space of α Lipschitz functions (see Definition 4.1 in appendix). As we employ functions that are BLI the impact of the approximation error remains controlled.
+
+Proposition 1.7 Approximate representation: Let $\Phi _ { L } \circ \cdots \circ \Phi _ { 1 }$ be a BLI function from $l ^ { 2 } ( \mathbb { Z } )$ onto $l ^ { 2 } ( \mathbb { Z } )$ . Let $P _ { W } ^ { l }$ be the projection operator from $L ^ { 2 } ( [ 0 , 1 ] )$ onto a Wavelet basis of $l$ scales,
+
+$$
+\big \| \Phi _ { L } \circ \cdots \circ \Phi _ { 1 } \circ P _ { W } ^ { [ \log _ { 2 } ( N ) ] } \big ( f \big ) - \Phi _ { L } \circ \cdots \circ \Phi _ { 1 } P _ { W } ^ { + \infty } \big ( f \big ) \big \| _ { 2 } ^ { 2 } = O \big ( 2 ^ { - N 2 \alpha } \big ) .
+$$
+
+In other words, the numerical representation can be arbitrarily close to the true representation of smooth, continuous-time functions with compact support. Indeed, if $W$ is a wavelet basis, then $\operatorname { P r o j } _ { W } ^ { + \infty } ( f ) = f$ . The argument stresses the critical role of our assumption of the Lipschitz-ness of ( ) =frames and the BLI functions which guarantees that representations based on approximations can be arbitrarily accurate.
+
+# 2 ORTHOGONAL MULTI-RESOLUTION CONVOLUTIONS IN TIME
+
+So far, we have focused on sufficient conditions to make accurate representation of continuous-time signals possible as they are observed randomly and as the corresponding observation are processed non-linearly. We now show that additional conditions on time-domain convolutional filter banks further guarantee that the representation is minimal (i.e., produces orthogonal outputs).
+
+# 2.1 MULTI-RESOLUTION REPRESENTATION
+
+As our goal is to obtain different representations of a time series while avoiding redundancy, let us introduce multi-resolution approximations (Mallat, 2008).
+
+Definition 2.1 Multi-resolution approximation: A family $( H _ { l } ) _ { l \in \mathbb { Z } }$ of closed sub-spaces of $L ^ { 2 } ( \mathbb { R } )$ is a multi-resolution approximation if the family is nested $\forall l \in \mathbb { Z }$ , $H _ { l + 1 } \subset H _ { l } )$ ; dense $( \overline { { \cup _ { l \in \mathbb { Z } } H _ { l } } } =$ $L ^ { 2 } ( \mathbb { R } ) )$ ; separated $( \cap _ { l \in \mathbb { Z } } H _ { l } = \{ 0 \} )$ ); causal $( \forall l \in \mathbb { Z } , g ( \cdot ) \in H _ { l } \Rightarrow g ( \cdot / 2 ) \in H _ { l + 1 } )$ ∪ =; stable by translation $( \forall ( t , l ) \in \mathbb { Z } , g ( \cdot ) \in H _ { l } \Rightarrow g ( \cdot - 2 ^ { l } t ) \in H _ { l } )$ ). In addition we require that $\left( H _ { 0 } \right)$ there exists an orthonormal family $( S ( \cdot - n ) ) _ { n \in \mathbb { Z } }$ such that span $( ( S ( \cdot ) _ { n \in \mathbb { Z } } ) ) = H _ { l } ,$ , i.e. $S ( \cdot - n )$ is a Riesz basis of $H _ { 0 }$ with scaling function $S$ .
+
+Such Riesz basis is proven to exist in (Mallat, 2008); the family of Haar wavelets is merely an example. General conditions for a function $S \in L ^ { 2 } ( \mathbb { R } )$ to be a scaling function are given by the following theorem.
+
+Theorem 2.1 Conjugate mirror temporal convolution layer (CMConv): (Mallat, 1989) Let $\kappa _ { S }$ and $\kappa _ { W }$ in $l ^ { 2 } ( \mathbb { Z } )$ be two convolution filters such that
+
+$$
+\begin{array} { r l } & { F T [ \kappa _ { S } ] ( 0 ) = \sqrt { 2 } , } \\ & { \forall \omega \in [ - 1 / 2 , 1 / 2 ] , | F T [ \kappa _ { S } ] ( \omega ) | ^ { 2 } + | F T [ \kappa _ { S } ] ( \omega + 1 / 2 ) | ^ { 2 } = 2 , } \\ & { \kappa _ { W n } = ( - 1 ) ^ { 1 - n } \kappa _ { S - n } . } \end{array}
+$$
+
+We further assume that $\mathrm { i n f } _ { f \in [ - \frac { 1 } { 4 } , \frac { 1 } { 4 } ] } ~ F T [ \kappa _ { S } ] ( f ) ~ > ~ 0$ . The inverse Fourier Transform of $\omega $ $\begin{array} { r } { \Pi _ { p = 1 } ^ { + \infty } \frac { F T [ \kappa _ { S } ] ( 2 ^ { - p } \omega ) } { \sqrt { 2 } } } \end{array}$ 4 4is a scaling function $S$ of $L ^ { 2 } ( \mathbb { R } )$ > for a multi-resolution approximation. Moreover, the Wavelet function $W$ defined as the inverse Fourier transform of $\scriptstyle { \frac { 1 } { \sqrt { 2 } } } F T [ \kappa _ { W } ] F T [ S ]$ is such that for any scale $\begin{array} { r } { \iota \left\{ W _ { l , n } = \frac { 1 } { \sqrt { 2 ^ { l } } } W \left( \frac { \cdot - 2 ^ { l } n } { 2 ^ { l } } \right) \left| n \in \mathbb { Z } \right. \right\} } \end{array}$ is an orthonormal basis $W _ { l }$ defined as the orthogonal complement of $H _ { l }$ in $H _ { l + 1 }$ . In particular, $( W _ { l , n } ) _ { l \in \mathbb { Z } , n \in \mathbb { Z } }$ is an orthonormal basis of $L ^ { 2 } ( \mathbb { R } )$ .
+
+2.2 DEPTH-WISE SEPARABLE CONVOLUTIONS AND MULTI-RESOLUTION APPROXIMATIONS
+
+We now show how depth-wise separable convolutions with scaling and wavelet filters quickly come with guarantees of orthogonality.
+
+In the following we consider an input space with $d$ input channels and a series of affine operators with increasing output dimensions $( d _ { l } ) _ { l = 1 } ^ { \hat { L } }$ . We denote $\mathcal { F } _ { S ( \cdot - t _ { n } ) _ { n \in \mathbb { Z } } }$ by $\mathcal { F }$ to simplify notations.
+
+Theorem 2.2 Conjugate mirror convolutions and FDFC: Consider two convolution filters $\kappa _ { S }$ and $\kappa _ { W }$ , if $\kappa _ { S } , \kappa _ { W }$ respect the conditions Eq. (4) and $\mathrm { i n f } _ { \omega \in [ - \frac { 1 } { 4 } , \frac { 1 } { 4 } ] } \ F T [ \kappa _ { S } ] ( \omega ) > 0$ , then $\kappa _ { S } , \kappa _ { W }$ constitute a pair of RConv filters. Consider the function which to $f \in L _ { d } ^ { 2 } ( \mathbb { R } )$ associates $( \theta _ { l } ( f ) ) _ { l = 1 \ldots L }$
+
+$$
+f  ( < f , S ( \cdot - n ) > ) _ { n \in \mathbb { Z } } \quad \begin{array} { c c c c c c } { ( \kappa _ { W } * \cdot ) [ : : 2 ] } & { B L I } & { \cdot . . . } & { \cdot . . . } & {  ( \theta _ { 1 } ( f ) _ { n } ) _ { n \in \mathbb { Z } } } \\ {  } & { ( \kappa _ { W } * ) [ : : 2 ] } & { B L I } & { \cdot . . . } & {  I \ I ( \theta _ { 2 } ( f ) _ { n } ) _ { n \in \mathbb { Z } } } \\ { \kappa _ { S } * ) [ : 2 ] } & { } & {  } & { \cdot . . . } & { \vdots } \\ { \hphantom { ( } \kappa _ { S } * \cdot ) [ : 2 ] } & { } & { \hphantom { ( } \kappa _ { S } * \cdot ) [ : 2 ] } & { \cdot . . . } & { \hphantom { ( } \vdots } \\ { \hphantom { ( } \kappa _ { S } * \cdot ) [ : 2 ] } & { \ddots } & { \hphantom { ( } } & { \kappa L I } \\ & { } & { \hphantom { ( } \theta _ { L } ( f ) _ { n } ) _ { n \in \mathbb { Z } } } \end{array} 
+$$
+
+The representation $( \theta _ { l } ( f ) ) _ { l = 1 \ldots L }$ is a non-linear frame that only depends on the coordinates of $f$ in an orthonormal basis of $L ^ { 2 } ( \mathbb { R } )$ .
+
+Proof 2.1 We start the proof by showing that $( x _ { n } ) \in l ^ { 2 } ( \mathbb { Z } ) \to \left( \left[ ( \kappa _ { W } * x ) _ { 2 n } , ( \kappa _ { S } * x ) _ { 2 n } \right] \right) \in l ^ { 2 } ( \mathbb { Z } )$ ( ) ∈ ( ) → ([(is a RConv reconstructible convolution layer. Based on Eq. (4), as $\kappa _ { W n } = ( - 1 ) ^ { 1 - n } \kappa _ { - n } ^ { S }$ ) ∈ ( )we have ${ \cal F T } [ \kappa _ { W } ] ( \omega ) = e ^ { i \pi \omega } { \overline { { { \cal F T } [ \kappa _ { S } ] ( \omega + \frac { 1 } { 2 } ) } } }$ and then as $\forall \omega \in \left[ - 1 / 2 , 1 / 2 \right]$ , $| F T [ \kappa _ { S } ] ( \omega ) | ^ { 2 } + | F T [ \kappa _ { S } ] ( \omega +$
+
+$1 / 2 ) | ^ { 2 } = 2$ the first part of the proof is concluded. The second part of the proof utilizes the fact that the cascading convolutions above compute a Discrete Wavelet Transform Mallat (2008). Therefore, $( \theta _ { 1 } ( f ) _ { n } ) _ { n \in \mathbb { Z } } \ = \ ( \theta _ { 1 } ( < \ f , W _ { 1 , n } > ) _ { n } ) _ { n \in \mathbb { Z } } ,$ $( \theta _ { 2 } ( f ) _ { n } ) _ { n \in \mathbb { Z } } \ = \ ( \theta _ { 2 } ( < f , W _ { 2 , n } \ >$ $) _ { n } ) _ { n \in \mathbb { Z } } , \ldots , ( \theta _ { L - 1 } ( f ) _ { n } ) _ { n \in \mathbb { Z } } = ( \theta _ { L - 1 } ( < f , W _ { L - 1 , n } > ) _ { n } ) _ { n \in \mathbb { Z } }$ and $( \theta _ { 1 } ( f ) _ { n } ) _ { n \in \mathbb { Z } } = ( \theta _ { L } ( < f , S _ { L - 1 , n } >$ $) _ { n } ) _ { n \in \mathbb { Z } }$ where $\begin{array} { r } { \left\{ S _ { l , n } = \frac { 1 } { \sqrt { 2 ^ { l } } } S \left( \frac { \mathrel { \cdot } - 2 ^ { l } n } { 2 ^ { l } } \right) \big | n \in \mathbb { Z } \right\} } \end{array}$ . ∎
+
+The cascaded time domain convolutions being computed yield the coordinates of $f$ in an orthonormal basis. Therefore, as the orthogonal CNN grows deeper it can only yield novel orthogonal information about the input signal that is informative of its properties on a particular temporal scale. Such is the nature of our efficiency claim for the neural networks we consider. A key point here is that the 1x1 convolutions operate in depth and not along the axis of time which preserves the temporal scaling properties of the Discrete Wavelet Transform.
+
+# 2.3 TRAINING OF RCONV LAYERS BY ALTERNATING SGD STEPS AND DC PROGRAMMING:
+
+As noted in Mallat (2008) the constraint $\operatorname { i n f } _ { \omega \in \left[ - \frac { 1 } { 4 } , \frac { 1 } { 4 } \right] }$ , $| F T [ \kappa _ { S } ] ( \omega ) | > 0$ is always met in practice, which our numerical experiments confirm. The two critical constraints on the design of the temporal convolution filters is (1) that $\kappa _ { W } = ( - 1 ) ^ { 1 - n } \kappa _ { S } [ : : - 1 ]$ and $F T [ \kappa _ { S } ] ( 0 ) = \sqrt { 2 }$ , which is trivial to enforce, and (2) that $\forall \omega \in \mathbb { R }$ , $\begin{array} { r } { | F T [ \kappa _ { S } ] ( \omega ) | ^ { 2 } + | F T [ \kappa _ { S } ] ( \omega + \frac { 1 } { 2 } ) | ^ { 2 } = 2 . } \end{array}$
+
+In our implementation we approximate the constraint by computing the Fast Fourier Transform of the filter, since it is defined discretely in time by a finite set of weights. Therefore, we interleave the normal training step of $\kappa _ { S }$ with solving the following following minimization problem
+
+$$
+\operatorname* { m i n } _ { \kappa _ { S } \in \mathbb { R } ^ { H } } \sum _ { \omega = 0 , \frac { 1 } { N - 1 } } ^ { 1 } \Big | | F T [ \kappa _ { S } ] ( \omega ) | ^ { 2 } + | F T [ \kappa _ { S } ] ( \omega + \frac { 1 } { 2 } ) | ^ { 2 } - 2 \Big |
+$$
+
+where $H$ is the number of free parameters we allow in our temporal convolution filter. Such an optimization problem can be rewritten as a difference of convex (DC) functions (as $| x | = \operatorname* { m a x } ( 0 , x ) -$ $\begin{array} { r } { \operatorname* { m i n } ( 0 , x ) , \kappa _ { s }  | F T [ \kappa _ { S } ] ( \omega ) | ^ { 2 } + | F T [ \kappa _ { S } ] ( \omega + \frac { 1 } { 2 } ) | ^ { 2 } - 2 } \end{array}$ is clearly convex and convexity is stable by composition by a non-decreasing function) and an adapted solver (Tao & An, 1998) can then take advantage of the particular structure of the problem to find an optimal solution rapidly.
+
+# 3 NUMERICAL EXPERIMENTS
+
+Here, we show that the sufficient conditions for neural networks to yield non-linear frames are computationally tractable. The following experiments explore the empirical properties of such neural networks compared to various baselines.
+
+# 3.1 SYNTHETIC COMPRESSION EXPERIMENT
+
+In our first numerical experiment, we generate regularly sampled non-stationary stochastic processes, characterized by a random mixture of Gabor functions (Mallat, 2008) and step functions. As shown in Figure 2, the resulting signals are highly irregular, lack permanent seasonality, and have compact support. The objective here is to devise a procedure to train conjugate mirror (convolutional) filters with stochastic optimization methods to progressively improve representational power.
+
+We train a 16 parameter filter $\kappa _ { S }$ to optimally conduct the following compression (i.e., auto-encoding) task. The pair of filters specified in Eq. (4) are employed as in Theorem 2.2 to produce the coordinates of the input signal in the wavelet basis corresponding to the (learned) filters $\kappa _ { S }$ and $\kappa _ { W }$ . The input signals are uni-variate with 128 observations each.The encoding, therefore, initially consists of 128 scalar values, of which, only the 64 with higher magnitude are selected – all other values are set to 0.
+
+An inverse Discrete Wavelet Transform is then employed to reconstruct the input signal. The quality of this reconstruction is measured by the squared $L _ { 2 }$ loss, which penalizes discrepancies between the input signal and its reconstruction. To train this model, we use a stochastic optimization algorithm, RMSProp, to minimize the aforementioned loss. We train for 2,500 iterations with a learning rate of $1 0 ^ { - 3 }$ . This optimization is interleaved with a constraint enforcing program that enforces Eq. (4) every
+
+![](images/104370dfe3db195f899f62b0f4821678616f830a88147ac50021a2b51a4fae0c.jpg)  
+Figure 2: For a ratio of compression of 2, the learned wavelet basis auto-encoder outperforms an LSTM-based auto-encoder with the same number of parameters.
+
+100 iterations. Figure 2 shows that this procedure progressively improves the randomly-initialized filters and significantly out-performs an LSTM-based auto-encoder model.
+
+# 3.2 MULTI-SCALE VIDEO CLASSIFICATION
+
+We further show that a wavelet representation can be composed with classical recurrent architecture (in regularly observed settings) to mitigate the effect of noisy data. This is particularly useful for LSTM networks Hochreiter & Schmidhuber (1997), since hyperbolic tangent layers tend to saturate in the presence of high-magnitude perturbations.
+
+The YouTube-8M data-set contains millions of YouTube videos and their associated genres (AbuEl-Haija et al., 2016). Because the frames in each video are pre-featurized (i.e., a time series of featurized frames), models designed for this data-set must solely leverage the temporal structure in the data. In particular, the raw video feed is not available. A thorough description of the baselines we employ is available in Abu-El-Haija et al. (2016). This has enabled the authors of the paper to achieve state-of-the-art results in video classifications using a 2-layer LSTM model.
+
+In our experiment, we train a similar model to learn on a multi-scale wavelet representation of data. This representation separates the original time series into $d$ scales, varying from fine to coarse. Each of the $d$ time series in this multi-scale representation are fed into a similar 2-layer LSTMs with $d ^ { 2 }$ times fewer parameters which results in a decrease of the total number of parameters in the recurrent layers by a factor of $d$ . The outputs of each LSTM, are then concatenated before the final soft-max layer. We provide a model diagram detailing these components in the appendix. Our experimental results in Figure 3 indicate that this multi-scale representation greatly improves the performance of recurrent neural networks while using far fewer parameters.
+
+# 3.3 MULTI-SCALE FINANCIAL FORECASTING
+
+In 2015, an astounding medium volume of 40 million shares of AAPL (Apple Inc.) were traded each day. With the price of each share at approximately 100 USD, each 15-minute trading period represents an exchange of 142 million USD. Trades are highly irregular events characterized by an instantaneous exchange of shares between actors. Forecasting trade volume at a very fine resolution is essential in leveraging arbitrage opportunities. However, the noisy nature of financial markets makes this task incredibly challenging (Abergel et al., 2012).
+
+Using AAPL price data from 2015, we train two neural networks: a standard LSTM and a wavelet transform network, to predict the next 15 minutes of trading given the 15 minutes that have just elapsed. On average, the duration between time-stamps was $9 0 7 \mathrm { m s }$ (25th percentile: 200ms, median: 220ms, 75th percentile: $1 8 0 0 \mathrm { m s } , \quad$ ).
+
+![](images/b58c84f9b51053bc3bba0af122f5d9e27ba63c9ba53154a991e6312212bb6e0d.jpg)  
+Figure 3: Top: An LSTM model trained on a wavelet-transformed YouTube-8M data-set achieves comparable results against the baseline while using half the number of parameters. Bottom: Table evaluating the wavelet-transformed LSTM model against the results from Abu-El-Haija et al. (2016) on held-out data.
+
+![](images/6698584eddf7271e7382cc013d17c464d55b2daf116f377e6f17769868d2e864.jpg)  
+Figure 4: Predicting trade volume of a 15 minute window given the previous 15 minutes of observations. We evaluate the performance of neural networks against a simple averaging model. Even with $L _ { 1 }$ regularization, the LSTM does not have the same predictive power as the neural network specified in Theorem 2.2 with $L = 2$ or $L = 4$ .
+
+After the first scale projection onto a Haar wavelet basis (Mallat, 2008) is produced (with a characteristic resolution $\tau = 8$ seconds), both the wavelet transform network (with $M = 8$ ) and the LSTM make predictions with this first scale as input. Each model is evaluated by the $L _ { 2 }$ loss against a baseline predicting a constant trading volume equal to the average over the previous 15 observed minutes. Notice that in Figure 4, the LSTM struggles with the noisiness of the data, whereas the wavelet transform network is robust, and manages to improve the prediction performance by a half-percent. This half-percent represents 50 thousand USD of exchanged volume over a 15 minute period.
+
+# 4 CONCLUSION
+
+In this article, we analyze neural networks from a frame theoretic perspective. In doing so, we come to the conclusion that by considering time series as an irregularly observed continuous-time stochastic processes, we are better able to devise robust and efficient convolutional neural networks. By leveraging recent contributions to frame theory, we prove properties about non-linear frames that allow us to make guarantees over an entire class of convolutional neural networks. Particularly regarding their capacity to produce discrete representations of continuous time signals that are both injective and bi-Lipschitz. Moreover, we show that, under certain conditions, these properties almost certainly hold, even when the signal is irregularly observed in an event-driven manner. Finally, we show that bounded-output recurrent neural networks do not satisfy the sufficient conditions to yield non-linear frames.
+
+This article is not limited to the theoretical statements it makes. In particular, we show that we can build a convolutional neural network that effectively computes a Discrete Wavelet Transform. The network’s filters are dynamically learned while being constrained to produce outputs that preserve both orthogonality and the properties associated with non-linear frames. Our numerical experiments on real-world prediction tasks further demonstrate the benefits of such neural networks. Notably, their ability to produce compact representations that allow for efficient learning on latent continuous-time stochastic processes.
+
+# REFERENCES
+
+Frédéric Abergel, Jean-Philippe Bouchaud, Thierry Foucault, Charles-Albert Lehalle, and Mathieu Rosenbaum. Market microstructure: confronting many viewpoints. John Wiley & Sons, 2012.
+
+Sami Abu-El-Haija, Nisarg Kothari, Joonseok Lee, Paul Natsev, George Toderici, Balakrishnan Varadarajan, and Sudheendra Vijayanarasimhan. Youtube- $. 8 \mathrm { m }$ : A large-scale video classification benchmark. arXiv preprint arXiv:1609.08675, 2016.
+
+Emmanuel Bacry, Iacopo Mastromatteo, and Jean-François Muzy. Hawkes processes in finance. Market Microstructure and Liquidity, 1(01):1550005, 2015.
+
+Bhavik R Bakshi and George Stephanopoulos. Wave-net: A multiresolution, hierarchical neural network with localized learning. AIChE Journal, 39(1):57–81, 1993.
+
+Francois Belletti, Evan Sparks, Alexandre Bayen, and Joseph Gonzalez. Random projection design for scalable implicit smoothing of randomly observed stochastic processes. In Artificial Intelligence and Statistics, pp. 700–708, 2017.
+
+John J Benedetto. Irregular sampling and frames. wavelets: A Tutorial in Theory and Applications, 2: 445–507, 1992.
+
+John J Benedetto and Paulo JSG Ferreira. Modern sampling theory. Sankhya: The Indian Journal of Statistics, 65(Part 4):849–851, 2003.
+
+John J Benedetto and William Heller. Irregular sampling and the theory of frames, i. Note di Matematica, 10(suppl. 1):103–125, 1990.
+
+Yoshua Bengio, Paolo Frasconi, and Patrice Simard. The problem of learning long-term dependencies in recurrent networks. In Neural Networks, 1993., IEEE International Conference on, pp. 1183– 1188. IEEE, 1993.
+
+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.
+
+Kyunghyun Cho, Bart Van Merriënboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Holger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. arXiv preprint arXiv:1406.1078, 2014.
+
+François Chollet. Xception: Deep learning with depthwise separable convolutions. arXiv preprint arXiv:1610.02357, 2016.
+
+Daryl J Daley and David Vere-Jones. An introduction to the theory of point processes: volume II: general theory and structure. Springer Science & Business Media, 2007.
+
+Hans G Feichtinger and Karlheinz Gröchenig. Theory and practice of irregular sampling. Wavelets: mathematics and applications, 1994:305–363, 1994.
+
+Alex Graves, Abdel-rahman Mohamed, and Geoffrey Hinton. Speech recognition with deep recurrent neural networks. In Acoustics, speech and signal processing (icassp), 2013 ieee international conference on, pp. 6645–6649. IEEE, 2013.
+
+Karlheinz Gröchenig. Reconstruction algorithms in irregular sampling. Mathematics of computation, 59(199):181–194, 1992.
+
+Sepp Hochreiter and Jürgen Schmidhuber. Long short-term memory. Neural computation, 9(8): 1735–1780, 1997.
+
+Nicolas Huth and Frédéric Abergel. High frequency lead/lag relationships—empirical facts. Journal of Empirical Finance, 26:41–58, 2014.
+
+Lukasz Kaiser, Aidan N Gomez, and Francois Chollet. Depthwise separable convolutions for neural machine translation. arXiv preprint arXiv:1706.03059, 2017.
+
+Vadim Lebedev, Yaroslav Ganin, Maksim Rakhuba, Ivan Oseledets, and Victor Lempitsky. Speeding-up convolutional neural networks using fine-tuned cp-decomposition. arXiv preprint arXiv:1412.6553, 2014.
+
+Yann LeCun and Yoshua Bengio. Convolutional networks for images, speech, and time series. The handbook of brain theory and neural networks, 3361(10):1995, 1995.
+
+Liangda Li and Hongyuan Zha. Dyadic event attribution in social networks with mixtures of hawkes processes. In Proceedings of the 22nd ACM international conference on Conference on information & knowledge management, pp. 1667–1672. ACM, 2013.
+
+Stephane Mallat. A wavelet tour of signal processing: the sparse way. Academic press, 2008.
+
+Stephane G Mallat. A theory for multiresolution signal decomposition: the wavelet representation. IEEE transactions on pattern analysis and machine intelligence, 11(7):674–693, 1989.
+
+Daniel Neil, Michael Pfeiffer, and Shih-Chii Liu. Phased lstm: Accelerating recurrent network training for long or event-based sequences. In Advances in Neural Information Processing Systems, pp. 3882–3890, 2016.
+
+Yosihiko Ogata. Statistical models for earthquake occurrences and residual analysis for point processes. Journal of the American Statistical association, 83(401):9–27, 1988.
+
+Qiyu Sun and Wai-Shing Tang. Nonlinear frames and sparse reconstructions in banach spaces. Journal of Fourier Analysis and Applications, 23(5):1118–1152, 2017.
+
+Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In Advances in neural information processing systems, pp. 3104–3112, 2014.
+
+Pham Dinh Tao and Le Thi Hoai An. A dc optimization algorithm for solving the trust-region subproblem. SIAM Journal on Optimization, 8(2):476–505, 1998.
+
+Aäron van den Oord, Sander Dieleman, Heiga Zen, Karen Simonyan, Oriol Vinyals, Alex Graves, Nal Kalchbrenner, Andrew Senior, and Koray Kavukcuoglu. Wavenet: A generative model for raw audio. CoRR abs/1609.03499, 2016.
+
+Shuang-Hong Yang and Hongyuan Zha. Mixture of mutually exciting processes for viral diffusion. In International Conference on Machine Learning, pp. 1–9, 2013.
+
+Qingyuan Zhao, Murat A Erdogdu, Hera Y He, Anand Rajaraman, and Jure Leskovec. Seismic: A self-exciting point process model for predicting tweet popularity. In Proceedings of the 21th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 1513–1522. ACM, 2015.
+
+# CONVERGENCE OF WAVELET APPROXIMATIONS IN HOLDER FUNCTIONAL SPACES
+
+We rely on Wavelet approximations (Mallat, 2008) to represent signals that are not band-limited. Given a certain Wavelet function W ∈ L2(R) and Wl,τ = √12l a series of dilated and translated versions of $W$ , a Wavelet approximation expresses a function $f \in L ^ { 2 } ( \mathbb { R } )$ as
+
+$$
+f \simeq \mathrm { P } _ { W } ^ { L } ( f ) \sum _ { l = 0 } ^ { L - 1 } \sum _ { \tau \in \mathbb { Z } } < f , W _ { l , \tau } > W _ { l , \tau } .
+$$
+
+Under some conditions on $W$ (Mallat, 2008), the family $\begin{array} { r } { W _ { l , \tau } = \frac { 1 } { \sqrt { 2 ^ { l } } } W ( \frac {  \tau } { 2 ^ { l } } ) } \end{array}$ can be orthonormal and every function $f \in L ^ { 2 } ( \mathbb { R } )$ can be written in the limit as $\begin{array} { r } { f = \sum _ { l \in \mathbb { Z } } \sum _ { \tau \in \mathbb { Z } } < f , W _ { l , \tau } > W _ { l , \tau } } \end{array}$ . A ∑ ∑Wavelet function is defined as the high frequency mirror of a low frequency Scale function whose unit translations constitute a set of orthonormal atoms for a frame of $\mathbf { \dot { \mathbf { L } } ^ { 2 } } ( \mathbb { \dot { \mathbb { R } } } )$ (i.e. a Riesz basis of $L ^ { 2 } ( \mathbb { R } ) )$ .
+
+In the following we consider functions with bounded support and restrict our study to functions defined on the interval $[ 0 , 1 ]$ to simplify notations. A change of variable can immediately be employed to generalize the statements below to any bounded support function.
+
+Definition 4.1 Holder space of $\alpha$ Lipschitz functions: A function $f \in L ^ { 2 } ( [ 0 , 1 ] )$ is uniformly $\alpha$ Lipschitz if there exists $M > 0$ such that for all $s$ in $[ 0 , 1 ]$ ∈ there exists a polynomial $p _ { v }$ of degree $\lfloor \alpha \rfloor$ such that
+
+$$
+\forall t \in [ 0 , 1 ] , | f ( t ) - p _ { v } ( t ) | \leq K | t - s | ^ { \alpha } .
+$$
+
+In other words we consider functions defined on compacts that can be well approximated by polynomial splines and therefore have a certain degree of smoothness.
+
+Proposition 4.1 Wavelet approximation of smooth functions with compact support: If $f ^ { \mathrm { ~ ~ } } \in$ $L ^ { 2 } ( { \bar { [ 0 , 1 ] } } )$ is $\alpha$ Lipschitz there exist $0 < m \leq M$ ∈such that the approximation error of the wavelet decomposition with wavelet function $W$ < ≤and scale function $S$ is
+
+$$
+| f - ( \sum _ { l = L + 1 } ^ { \lfloor \log _ { 2 } ( N ) \rfloor \ge \sum _ { \tau = 0 } ^ { \tau } } < f , W _ { l , \tau } > W _ { l , \tau } + \sum _ { \tau = 0 } ^ { \lfloor \log _ { 2 } ( N ) \rfloor - 1 } < f , S _ { \lfloor \log _ { 2 } ( N ) \rfloor , \tau } > S _ { \lfloor \log _ { 2 } ( N ) \rfloor , \tau } ) | | _ { 2 } ^ { 2 } = O ( 2 ^ { - N 2 \alpha } )
+$$
+
+The proposition above, proven in (Mallat, 2008) helps us examine how such an approximation affects the representations we employ.
+
+# NEURAL ARCHITECTURES EMPLOYED IN THE VIDEO CLASSIFICATION EXPERIMENT
+
+The present section of the appendix describes in detail the architectures employed in our Youtube8 video classification experiments. In Figure 5 we present the baseline architecture in the form of a block-diagram. In Figure 6 we expose our architectural choices which split the input into independent sub-spaces of representation that all correspond to different characteristic scales of variation of the input signal.
+
+![](images/f71439b021b51b3eb60a72382ca4517f6244b61c574b9c5e723652d7744befd3.jpg)  
+Figure 5: Baseline architecture from (Abu-El-Haija et al., 2016).
+
+![](images/b522dc3af188946fe480c552723de8d311cb9a8294b081c2928753456b289c25.jpg)  
+Figure 6: The architecture we propose for the Youtube video classification task that leverages a multi-resolution approximation computed by a wavelet convolution stack.

parse/train/jM76BCb6F9m/jM76BCb6F9m.md

@@ -0,0 +1,311 @@
+# LEAF: A LEARNABLE FRONTEND FOR AUDIO CLASSIFICATION
+
+Neil Zeghidour, Olivier Teboul, Felix de Chaumont Quitry & Marco Tagliasacchi ´ Google Research {neilz, oliviert, fcq, mtagliasacchi}@google.com
+
+# ABSTRACT
+
+Mel-filterbanks are fixed, engineered audio features which emulate human perception and have been used through the history of audio understanding up to today. However, their undeniable qualities are counterbalanced by the fundamental limitations of handmade representations. In this work we show that we can train a single learnable frontend that outperforms mel-filterbanks on a wide range of audio signals, including speech, music, audio events and animal sounds, providing a general-purpose learned frontend for audio classification. To do so, we introduce a new principled, lightweight, fully learnable architecture that can be used as a drop-in replacement of mel-filterbanks. Our system learns all operations of audio features extraction, from filtering to pooling, compression and normalization, and can be integrated into any neural network at a negligible parameter cost. We perform multi-task training on eight diverse audio classification tasks, and show consistent improvements of our model over mel-filterbanks and previous learnable alternatives. Moreover, our system outperforms the current state-of-the-art learnable frontend on Audioset, with orders of magnitude fewer parameters.
+
+# 1 INTRODUCTION
+
+Learning representations by backpropagation in deep neural networks has become the standard in audio understanding, ranging from automatic speech recognition (ASR) (Hinton et al., 2012; Senior et al., 2015) to music information retrieval (Arcas et al., 2017), as well as animal vocalizations (Lostanlen et al., 2018) and audio events (Hershey et al., 2017; Kong et al., 2019). Still, a striking constant along the history of audio classification is the mel-filterbanks, a fixed, hand-engineered representation of sound. Mel-filterbanks first compute a spectrogram, using the squared modulus of the short-term Fourier transform (STFT). Then, the spectrogram is passed through a bank of triangular bandpass filters, spaced on a logarithmic scale (the mel-scale) to replicate the non-linear human perception of pitch (Stevens & Volkmann, 1940). Eventually, the resulting coefficients are passed through a logarithm compression, to replicate our non-linear sensitivity to loudness (Fechner et al., 1966). This approach of drawing inspiration from the human auditory system to design features for machine learning has been historically successful (Davis & Mermelstein, 1980; Mogran et al., 2004). Moreover, decades after the design of mel-filterbanks, Anden & Mallat ´ (2014) showed that they coincidentally exhibit desirable mathematical properties for representation learning, in particular shift-invariance and stability to small deformations. Hence, both from an auditory and a machine learning perspective, mel-filterbanks represent strong audio features.
+
+However, the design of mel-filterbanks is also flawed by biases. First, not only has the mel-scale been revised multiple times (O’Shaughnessy, 1987; Umesh et al., 1999), but also the auditory experiments that led their original design could not be replicated afterwards (Greenwood, 1997). Similarly, better alternatives to log-compression have been proposed, like cubic root for speech enhancement (Lyons & Paliwal, 2008) or 10th root for ASR (Schluter et al., 2007). Moreover, even though matching human perception provides good inductive biases for some application domains, e.g., ASR or music understanding, these biases may also be detrimental, e.g. for tasks that require fine-grained resolution at high frequencies. Finally, the recent history of other fields like computer vision, in which the rise of deep learning methods has allowed learning representations from raw pixels rather than from engineered features (Krizhevsky et al., 2012), inspired us to take the same path.
+
+![](images/003a0d0b590f2740367e849212a5e09db4a86bbac1184aaf4028bf9d7416e280.jpg)  
+Figure 1: Breakdown of the computation of mel-filterbanks, Time-Domain filterbanks, SincNet, and the proposed LEAF frontend. Orange boxes are fixed, while computations in blue boxes are learnable. Grey boxes represent activation functions.
+
+These observations motivated replacing mel-filterbanks with learnable neural layers, ranging from standard convolutional layers (Palaz et al., 2015) to dilated convolutions (Schneider et al., 2019), as well as structured filters exploiting the characteristics of known filter families, such as Gammatone (Sainath et al., 2015), Gabor (Zeghidour et al., 2018a; Noe et al.´ , 2020), Sinc (Ravanelli & Bengio, 2018; Pariente et al., 2020) or Spline (Balestriero et al., 2018) filters. While tasks such as speech separation have already successfully adopted learnable frontends (Luo & Mesgarani, 2019; Luo et al., 2019), we observe that most state-of-the art approaches for audio classification (Kong et al., 2019), ASR (Synnaeve et al., 2019) and speaker recognition (Villalba et al., 2020) still employ mel-filterbanks as input features, regardless of the backbone architecture.
+
+In this work, we argue that a credible alternative to mel-filterbanks for classification should be evaluated across many tasks, and propose the first extensive study of learnable frontends for audio over a wide and diverse range of audio signals, including speech, music, audio events, and animal sounds. By breaking down mel-filterbanks into three components (filtering, pooling, compression/normalization), we propose LEAF, a novel frontend that is fully learnable in all its operations, while being controlled by just a few hundred parameters. In a multi-task setting over 8 datasets, we show that we can learn a single set of parameters that outperforms mel-filterbanks, as well as previously proposed learnable alternatives. Moreover, these findings are replicated when training a different model for each individual task. We also confirm these results on a challenging, large-scale benchmark: classification on Audioset (Gemmeke et al., 2017). In addition, we show that the general inductive bias of our frontend (i.e., learning bandpass filters, lowpass filtering before downsampling, learning a per-channel compression) is general enough to benefit other systems, and propose a new, improved version of SincNet (Ravanelli & Bengio, 2018). Our code is publicly available1.
+
+# 2 RELATED WORK
+
+In the last decade, several works addressed the problem of learning the audio frontend, as an alternative to mel-filterbanks. The first notable contributions in this field emerged for ASR, with Jaitly & Hinton (2011) pretraining Restricted Boltzmann Machines from the waveform, and Palaz et al. (2013) training a hybrid DNN-HMM model, replacing mel-filterbanks by several layers of convolution. However, these alternatives, as well as others proposed more recently (Tjandra et al., 2017; Schneider et al., 2019), are composed of many layers, which makes a fair comparison with melfilterbanks difficult. In the following section, we focus on frontends that provide a lightweight, drop-in replacement to mel-filterbanks, with comparable capacity.
+
+# 2.1 LEARNING FILTERS FROM WAVEFORMS
+
+A first attempt at learning the filters of mel-filterbanks was proposed by Sainath et al. (2013), where a filterbank is initialized using the mel-scale and then learned together with the rest of the network, taking a spectrogram as input. Instead, Sainath et al. (2015) and Hoshen et al. (2015) later proposed to learn convolutional filters directly from raw waveforms, initialized with Gammatone filters (Schluter et al., 2007). In the same spirit, Zeghidour et al. (2018a) used the scattering transform approximation of mel-filterbanks (Anden & Mallat ´ , 2014) to propose the time-domain filterbanks, a learnable frontend that approximates mel-filterbanks at initialization and can then be learned without constraints (see Figure 1). More recently, the SincNet (Ravanelli & Bengio, 2018) model was proposed, which computes a convolution with sine cardinal filters, a non-linearity and a max-pooling operator (see Figure 1), as well as a variant using Gabor filters (Noe et al. ´ , 2020).
+
+We take inspiration from these works to design a new learnable filtering layer. As detailed in Section 3.1.2, we parametrize a complex-valued filtering layer with Gabor filters. Gabor filters are optimally localized in time and frequency (Gabor, 1946), unlike Sinc filters that require using a window function (Ravanelli & Bengio, 2018). Moreover, unlike Noe et al. ´ (2020), who use complex-valued layers in the rest of the network, we describe in Section 3.1.2 how using a squared modulus not only brings back the signal to the real-valued domain (leading to compatibility with standard architectures), but also performs shift-invariant Hilbert envelope extraction. Zeghidour et al. (2018a) also apply a squared modulus non-linearity, however as described in Section 3.1.1, training unconstrained filters can lead to overfitting and stability issues, which we solve with our approach.
+
+# 2.2 LEARNING THE COMPRESSION AND THE NORMALIZATION
+
+The problem of learning a compression and/or normalization function has received less attention in the past literature. A notable contribution is the Per-Channel Energy Normalization (PCEN) (Wang et al., 2017; Lostanlen et al., 2019), which was originally proposed for keyword spotting, outperforming log-compression. Later, Battenberg et al. (2017) and Lostanlen et al. (2018) confirmed the advantages of PCEN, respectively for large scale ASR and animal bioacoustics. However, these previous works learn a compression on top of fixed mel-filterbanks. Instead, in this work we propose a new version of PCEN and show for the first time that combining learnable filters, learnable pooling, and learnable compression and normalization outperforms all other approaches.
+
+# 3 MODEL
+
+Let $x \in \mathbb { R } ^ { T }$ denote a one-dimensional waveform of $T$ samples, available at the sampling frequency $F _ { s }$ [Hz]. We decompose the frontend into a sequence of three components: i) filtering, which passes $x$ through a bank of bandpass filters followed by a non-linearity, operating at the original sampling rate $F _ { s }$ ; ii) pooling, which decimates the signal to reduce its temporal resolution; iii) compression/normalization, which applies a non-linearity to reduce the dynamic range. Overall, the frontend can be represented as a function $\mathcal { F } _ { \psi } : \mathbb { R } ^ { T }  \mathbb { R } ^ { M \times N }$ , which maps the input waveform to a 2-dimensional feature space, where $M$ denotes the number of temporal frames (typically $M < T$ ), $N$ the number of feature channels (which might correspond to frequency bins) and $\psi$ the frontend parameters. The features computed by the frontend are then fed to a model $g _ { \theta } ( \cdot )$ parametrized by $\theta$ . The frontend and the model parameters are estimated by solving a supervised classification problem:
+
+$$
+\theta ^ { * } , \psi ^ { * } = \underset { \theta , \psi } { \arg \operatorname* { m i n } } E _ { ( x , y ) \in \mathcal { D } } \ : \mathcal { L } \big ( g _ { \theta } ( \mathcal { F } _ { \psi } ( x ) ) , y \big ) ,
+$$
+
+where $( x , y )$ are samples in a labelled dataset $\mathcal { D }$ and $\mathcal { L }$ is a loss function. Our goal is to learn the frontend parameters $\psi$ end-to-end with the model parameters $\theta$ . To achieve this, it is necessary to make all the frontend components learnable, so that we can solve the optimization problem in equation 1 with gradient descent. In the following we detail the design choices of each component.
+
+# 3.1 FILTERING
+
+The first block of the learnable frontend takes $x$ as input, and computes a convolution with a bank of complex-valued filters ${ { ( { \varphi _ { n } } ) } _ { n = 1 \dots N } }$ , followed by a squared modulus operator, which brings back its output to the real-valued domain. This convolution step has a stride of 1, therefore keeping the input temporal resolution, and outputs the following time-frequency representation:
+
+$$
+f _ { n } = | x * \varphi _ { n } | ^ { 2 } \in \mathbb R ^ { T } , \quad n = 1 , \dots , N ,
+$$
+
+where $\varphi _ { n } \in \mathbb { C } ^ { W }$ is a complex-valued 1-D filter of length $W$ . It is possible to compute equation 2 without explicitly manipulating complex numbers. As proposed by Zeghidour et al. (2018a), to produce the squared-modulus of a complex-valued convolution with $N$ filters, we compute instead the convolution with $2 N$ real-valued filters $\tilde { \varphi } _ { n } , n = 1 , \ldots , 2 N$ , and perform squared $\ell _ { 2 }$ -pooling with size 2 and stride 2 along the channel axis to obtain the squared modulus, using adjacent filters as real and imaginary part of $\varphi _ { n }$ . Formally:
+
+![](images/0679ecc25b24fb5cc92b1cd4d1d17b80031e02bd7879db13d3ef013bb9af4fa8.jpg)  
+Figure 2: Frequency response of filters at convergence for two parametrizations: normalized 1D filters and Gabor filters, both initialized on a mel scale. We highlight two filters among the 40 of the filterbank: one in yellow in the low frequency range and one in pink at high frequencies.
+
+$$
+f _ { n } = | x * \tilde { \varphi } _ { 2 n - 1 } | ^ { 2 } + | x * \tilde { \varphi } _ { 2 n } | ^ { 2 } \in \mathbb { R } ^ { T } , \quad n = 1 , \dots , N .
+$$
+
+We explore two different parametrizations for $\varphi _ { n }$ . One relies on standard fully parametrized convolutional filters while the other makes use of learnable Gabor filters.
+
+# 3.1.1 NORMALIZED 1D-CONVOLUTION
+
+Inspired by Zeghidour et al. (2018a), the first version of our filtering component is a standard 1D convolution, initialized with a bank of Gabor filters, which approximates the computation of a melfilterbank. Thus, at initialization, the output of the frontend is identical to that of a mel-filterbank, but during training the filters can be learned by backpropagation. In our early experiments, we observed several limitations of this approach. First, due to the unconstrained optimization, these filters not only learn to select frequency bands of interest, but also learn a scaling factor. This might lead to instability during training, because the same form of scaling can be also computed by the filter-wise compression component, which is applied at a later stage in the frontend. We address this issue by applying $\ell _ { 2 }$ -normalization to the filter coefficients before computing the convolution. Second, the unconstrained parametrization increases the number of degrees of freedom, making training prone to overfitting. The first panel in Figure 2 shows the frequency response of a bank of $N = 4 0$ filters, each parametrized with $W = 4 0 1$ coefficients. We observe that, at convergence, they are widely spread across the frequency axis, and include negative frequencies. Moreover, the filters are very spiky rather than smooth. To alleviate these issues, in the next section we introduce a parametrization based on a bank of Gabor filters, which reduces the number of parameters to learn, while at the same time enforcing during training a stable and interpretable representation.
+
+# 3.1.2 GABOR 1D-CONVOLUTION
+
+Gabor filters are produced by modulating a Gaussian kernel with a sinusoidal signal. These filters provide several desirable properties. First, they have an optimal trade-off between localization in time and frequency (Gabor, 1946), which makes them a suitable choice for a convolutional network with finite-sized filters. This is in contrast to Sinc filters (Ravanelli & Bengio, 2018), which require using a window function to smooth abrupt variations on each side of the filter. Second, the time and frequency response of Gabor filters have the same functional form, thus leading to interpretable bandpass filters, unlike the unconstrained filters described in the previous section. Finally, Gabor filters are quasi-analytic (i.e., their frequency response is almost zero for negative frequencies) and when combined with the squared modulus the resulting filterbank can be interpreted as a set of subband Hilbert envelopes, which are invariant to small shifts. Due to this desirable property, they have been previously used as (fixed) features for speech and speaker recognition (Falk & Chan, 2009; Thomas et al., 2008). Formally, Gabor filters are parametrized by their center frequencies $( \eta _ { n } ) _ { n = 1 \ldots N }$ and inverse bandwidths $( \sigma _ { n } ) _ { n = 1 \ldots N }$ as follows:
+
+$$
+\varphi _ { n } ( t ) = e ^ { i 2 \pi \eta _ { n } t } \frac { 1 } { \sqrt { 2 \pi } \sigma _ { n } } e ^ { - \frac { t ^ { 2 } } { 2 \sigma _ { n } ^ { 2 } } } , n = 1 , \dots , N , t = - W / 2 , \dots , W / 2 .
+$$
+
+The frequency response of $\varphi _ { n }$ is a Gaussian centered at frequency $\eta _ { n }$ and of bandwidth $1 / \sigma _ { n }$ , both expressed in normalized frequency units in $[ - 1 / 2 , + 1 / 2 ]$ . Therefore, learning these parameters allows learning a bank of smooth, quasi-analytic bandpass filters, with controllable center frequency and bandwidth. In practice, to compute the output of the filtering component, we obtain the impulse response of the Gabor filters $\varphi _ { n } ( t )$ over the range $t = - W / 2 , \dots , W / 2$ , and convolve these impulse responses with the input waveform. To ensure stability during training, we clip the center frequencies $( \eta _ { n } ) _ { n = 1 \ldots N }$ to be in $[ 0 , 1 / 2 ]$ , so that they lie in the positive part of the frequency range.√ √ We also constrain the bandwidths $( \sigma _ { n } ) _ { n = 1 \ldots N }$ in the range $[ 4 \dot { \sqrt { 2 \log 2 } } , \dot { 2 } W \sqrt { 2 \log 2 } ]$ , such that the full-width at half-maximum of the frequency response is within $1 / W$ and $1 / 2$ .
+
+Gabor filters have significantly fewer parameters than the normalized 1D-convolutions described in Section 3.1.1. $N$ filters of length $W$ are described by $2 N$ parameters, $N$ for the center frequencies and $N$ for the bandwidths, against $W \cdot N$ for a standard 1D-convolution. In particular, when using a window length of $2 5 \mathrm { m s }$ , operating at a sampling rate of $1 6 \mathrm { k H z }$ , then $W = 4 0 1$ samples, and Gabor-based filtering accounts for 200 times fewer parameters than their unconstrained alternatives.
+
+# 3.1.3 TIME-FREQUENCY ANALYSIS AND LEARNABLE FILTERS
+
+A spectrogram, in linear or mel scale, provides an ordered time-frequency representation: adjacent frames represent consecutive time-steps, while frequencies monotonically increase along the feature axis. A learnable frontend that performs filtering by means of convolution with a set of bandpass filters also preserves ordering along the temporal axis. However, the ordering along the feature axis is unconstrained. This can be problematic when applying subsequent operations that rely on frequency ordering. These include, for example: i) operations that leverage local frequency information, e.g., two-dimensional convolutions, which compute a feature representation based on local time-frequency patches; ii) operations that leverage long-range dependencies along the frequency axis, e.g., to capture the harmonic structure of the underlying signal; and iii) augmentation methods that mask adjacent frequency bands, like SpecAugment (Park et al., 2019). To evaluate the impact of enforcing an explicit ordering of the center frequencies of the learned filters, we compared the result of training a frontend using Gabor filters with or without explicitly enforcing ordering of the center frequencies. Interestingly, we observe that even without an explicit constraint, filters that are ordered at the initialization tend to keep the same ordering throughout training, and that enforcing sorted filters has no effect on the performance.
+
+# 3.2 LEARNABLE LOWPASS POOLING
+
+The output of the filtering component has the same temporal resolution as the input waveform. The second step of a learnable frontend is to downsample the output of the filterbank to a lower sampling rate, similarly to what happens in the STFT when computing mel-filterbanks. Previous work relied on max-pooling (Sainath et al., 2015; Ravanelli & Bengio, 2018; Noe et al. ´ , 2020), lowpassfiltering (Zeghidour et al., 2018a) or average pooling (Balestriero et al., 2018). Zeghidour et al. (2018b) compare these methods on a speech recognition task and show a systematic improvement when using lowpass filtering instead of max-pooling. More recently, Zhang (2019) showed that in standard 2D convolutional architectures, including ResNet (He et al., 2016) and DenseNet (Huang et al., 2017), a drop-in replacement of max-pooling and average pooling layers with a (fixed) lowpass filter improves the performance for image classification. In the proposed frontend, we extend the pooling layer of Zeghidour et al. (2018a) in two ways. First, while Zeghidour et al. (2018a) adopt a single shared lowpass filter for all input channels, we implement lowpass filtering by means of depthwise convolution, such that each input channel is associated with one lowpass filter. This is useful because each channel in the learnable frontend is characterized by a different bandwidth, and a specific lowpass filter can be learned for each of them. Second, we parametrize these lowpass filters to have a Gaussian impulse response:
+
+$$
+\phi _ { n } ( t ) = \frac { 1 } { \sqrt { 2 \pi } \sigma _ { n } } e ^ { - \frac { t ^ { 2 } } { 2 \sigma _ { n } ^ { 2 } } } , \quad t = - W / 2 , \dots , W / 2 .
+$$
+
+Note that this is a particular case of Gabor filters with center frequency equal to 0 and learnable bandwidth. With this choice, we can learn per-channel lowpass pooling functions while adding only $N$ parameters to the frontend model. We initialize all channels with a bandwidth of 0.4, which gives a frequency response close to the Hann window used by mel-filterbanks.
+
+# 3.3 LEARNING PER-CHANNEL COMPRESSION AND NORMALIZATION
+
+When using a traditional frontend based on a mel-filterbank or STFT, the time-frequency features are typically passed through a logarithmic compression, to replicate the non-linear human perception of loudness (Fechner et al., 1966). The first limitation of this approach is that the same compression function is applied to all frequency bins, regardless of their content. The second limitation is the fixed choice of the non-linearity used by the compression function. While, in most cases, a logarithmic function is used, other compression functions have been proposed and evaluated in the past, including the cubic root (Lyons & Paliwal, 2008) and the 10th root (Schluter et al., 2007). This motivates learning the compression function as part of the model, rather than relying on a handcrafted choice. In particular, Per-Channel Energy Normalization (Wang et al., 2017) was proposed as a learnable alternative to log-compression and mean-variance normalization:
+
+$$
+\mathrm { P C E N } ( \mathcal { F } ( t , n ) ) = \left( \frac { \mathcal { F } ( t , n ) } { { \left( \varepsilon + \mathcal { M } ( t , n ) \right) } ^ { \alpha _ { n } } } + \delta _ { n } \right) ^ { r _ { n } } - \delta _ { n } ^ { r _ { n } } ,
+$$
+
+where $t = 1 , \ldots , M$ denotes the time-step and $n = 1 , \ldots , N$ the channel index. In this parametrization, the time-frequency representation $\mathcal { F }$ is first normalized by an exponential moving average of its past values $\mathcal { M } ( t , n ) = ( 1 - s ) \mathcal { M } ( t - 1 , n ) + s \mathcal { F } ( t , n )$ , controlled by a smoothing coefficient $s$ and an exponent $\alpha _ { n }$ , with $\varepsilon$ being a small constant used to avoid dividing by zero. An offset $\delta _ { n }$ is then added before applying compression with the exponent $r _ { n }$ (typically in $[ 0 , 1 ] \cdot$ ). Wang et al. (2017) train $\alpha _ { n }$ , $\delta _ { n }$ , and $r _ { n }$ , while treating $s$ as a hyperparameter, or learning a convex combination of exponential moving averages for different, fixed values of $s$ . Instead, in this work we learn channel-dependent smoothing coefficients $s _ { n }$ , jointly with the rest of the parameters. We call this version sPCEN. This approach was previously used by Schluter & Lehner ¨ (2018) for singing voice detection, except that they did not learn the exponents $\alpha _ { n }$ , while we learn all these parameters jointly. Our final frontend cascades a Gabor 1D-convolution, a Gaussian lowpass pooling, and sPCEN. In the rest of the paper, we refer to this model as LEAF, for “LEarnable Audio Frontend”.
+
+# 4 EXPERIMENTS
+
+We evaluate our frontend on three supervised learning problems: i) single-task classification; ii) multi-task classification and iii) multi-label classification on Audioset. As baselines, we compare our system to log-compressed mel-filterbanks, learnable Time-Domain filterbanks (Zeghidour et al., 2018a)2 and SincNet (Ravanelli & Bengio, 2018)3. In all our experiments, we keep the same common backbone network architecture, which consists of a frontend, a convolutional encoder, and one (or more) head(s). We adopt the lightweight version of EfficientNet (Tan & Le, 2019) (EfficientNetB0, with $4 \mathrm { M }$ parameters) as convolutional encoder. On AudioSet, we also experiment with a state-of-the-art CNN14 encoder (Kong et al., 2019), with $8 1 \mathrm { M }$ parameters. A head is a single linear layer with a number of outputs equal to the number of classes. In the multi-task setting we use a different head for each of the target tasks, all sharing the same encoder.
+
+The input signal sampled at $F _ { s } = 1 6 \mathrm { k H z }$ is passed through the frontend which feeds into the convolutional encoder. As baseline, we use a log-compressed mel-filterbank with 40 channels, computed over windows of $2 5 \mathrm { m s }$ with a stride of $1 0 \mathrm { m s }$ . For a fair comparison, both LEAF and the learnable baselines also have $N = 4 0$ filters, each with $W = 4 0 1$ coefficients ${ \approx } 2 5 \mathrm { m s }$ at $1 6 \mathrm { k H z }$ ). The learnable pooling is computed over 401 samples with a stride of 160 samples $\mathrm { 1 0 m s }$ at $1 6 \mathrm { k H z }$ ), giving the same output dimension as mel-filterbanks. On AudioSet we use 64 channels instead of 40 as Kong et al. (2019) observed improvements from using 64 mel-filters.
+
+To address the variable length of the input sequences, we train on randomly sampled 1 second windows. We train with ADAM (Kingma & Ba, 2014) and a learning rate of $1 \dot { 0 } ^ { - 4 }$ for $1 \mathrm { M }$ batches, with batch size 256. For Audioset experiments, we train with mixup (Zhang et al., 2017) and SpecAugment (Park et al., 2019). During evaluation, we consider the full-length sequences, splitting them into consecutive non-overlapping 1 second windows and averaging the output logits over windows.
+
+Table 1: Test accuracy $( \% )$ for single-task classification.   
+
+<table><tr><td>Task</td><td>Mel</td><td>TD-fbanks</td><td>SincNet</td><td>LEAF</td></tr><tr><td>Acoustic scenes</td><td>99.2 ± 0.4</td><td>99.5 ± 0.3</td><td>96.7 ± 0.9</td><td>99.1 ± 0.5</td></tr><tr><td>Birdsong detection</td><td>78.6 ±1.0</td><td>80.9 ±0.9</td><td>78.0 ±1.0</td><td>81.4±0.9</td></tr><tr><td>Emotion recognition</td><td>49.1 ± 2.4</td><td>57.1 ± 2.4</td><td>44.2 ± 2.4</td><td>57.8±2.4</td></tr><tr><td>Speaker Id. (VC)</td><td>31.9 ± 0.7</td><td>25.3 ± 0.7</td><td>43.5 ± 0.8</td><td>33.1 ± 0.7</td></tr><tr><td>Music (instrument)</td><td>72.0± 0.6</td><td>70.0 ± 0.6</td><td>70.3± 0.6</td><td>72.0± 0.6</td></tr><tr><td>Music (pitch)</td><td>91.5 ± 0.3</td><td>91.3 ± 0.3</td><td>83.8 ± 0.5</td><td>92.0 ± 0.3</td></tr><tr><td>Speech commands</td><td>92.4±0.4</td><td>87.3 ± 0.4</td><td>89.2± 0.4</td><td>93.4±0.3</td></tr><tr><td>Language Id.</td><td>76.5 ± 0.4</td><td>71.6 ± 0.5</td><td>78.9 ± 0.4</td><td>86.0±0.4</td></tr><tr><td>Average</td><td>73.9 ±0.8</td><td>72.9 ± 0.8</td><td>73.1 ± 0.9</td><td>76.9 ± 0.8</td></tr></table>
+
+Table 2: Impact of the compression layer on the performance (single task, average accuracy in $\%$ ).   
+
+<table><tr><td rowspan="2"></td><td colspan="3">mel-filterbank</td><td colspan="3">LEAF- filterbank</td></tr><tr><td>log</td><td>PCEN</td><td>sPCEN</td><td>log</td><td>PCEN</td><td>sPCEN</td></tr><tr><td>Average</td><td>73.9 ± 0.8</td><td>76.4 ± 0.8</td><td>76.0 ± 0.7</td><td>74.6±0.7</td><td>76.4± 0.8</td><td>76.9 ± 0.8</td></tr></table>
+
+# 4.1 SINGLE-TASK AUDIO CLASSIFICATION
+
+We train independent single-task supervised models on 8 distinct classification problems: acoustic scene classification on TUT (Heittola et al., 2018), birdsong detection (Stowell et al., 2018), emotion recognition on Crema-D (Cao et al., 2014), speaker identification on VoxCeleb (Nagrani et al., 2017), musical instrument and pitch detection on NSynth (Engel et al., 2017), keyword spotting on Speech Commands (Warden, 2018), and language identification on VoxForge (Revay & Teschke, 2019). A summary of the datasets used in our experiments is illustrated in Table A.1.
+
+Table 1 reports the results for each task, with $9 5 \%$ confidence intervals representing the uncertainty due to the limited test sample size. No class rebalancing is applied, neither during training, nor during testing. On average, we observe that LEAF outperforms all alternatives. When considering results for each individual tasks, we observe that LEAF outperforms or matches the accuracy of other frontends, with the notable exception of SincNet on Voxceleb. This is consistent with the fact that SincNet was originally proposed for speaker identification (Ravanelli & Bengio, 2018) and illustrates the importance of evaluating over a wide range of tasks. To evaluate the robustness of our results with respect to the choice of the datasets, we apply a statistical bootstrap (Efron & Tibshirani, 1993) to compute the non-parametric distribution of the difference between the accuracy obtained with LEAF and each of the other frontends, when sampling datasets with replacement among the eight datasets. We test the null hypothesis that the mean of the difference is zero and measure the following one-sided $\mathsf { p }$ -values: $\dot { p _ { \mathrm { M e l } } } ~ < ~ 1 0 ^ { - 5 }$ , $ { p _ { \mathrm { T D - f b a n k s } } } ~ < ~ 1 0 ^ { - 5 }$ , $p _ { \mathrm { S i n c N e t } } ~ = ~ 0 . 0 5 9$ . Figure A.1 illustrates the corresponding bootstrap distribution, showing the statistical significance of our results with respect to the choice of the datasets. In Table 2, we study the effect of the compression function. PCEN improves significantly over log-compression on both mel- and learned filterbanks. We also observe that for any choice of the compression function, the learnable frontend matches or outperforms the corresponding mel-filterbank.
+
+# 4.2 MULTI-TASK AUDIO CLASSIFICATION
+
+To learn a general-purpose frontend that generalizes across tasks, we train a multi-task model that uses the same LEAF parameters and encoder for all tasks, with a task-specific linear head. More specifically, a single network with $K$ heads $( h _ { \theta _ { 1 } } , \ldots , h _ { \theta _ { K } } )$ is trained on mini-batches, uniformly sampled from the $K$ datasets. A mini-batch of size $B$ can be represented as $( x _ { i } ^ { k _ { i } } , y _ { i } ^ { k _ { i } } ) _ { i = 1 \dots B }$ , where $k _ { i }$ is the associated task the example has been sampled from. The multi-task loss function is now computed on a mini-batch as the sum of the individual loss functions:
+
+Table 3: Test accuracy $( \% )$ for multi-task classification.   
+
+<table><tr><td>Task</td><td>Mel</td><td>TD-fbanks</td><td>SincNet</td><td>LEAF</td></tr><tr><td>Acoustic scenes</td><td>99.1 ± 0.5</td><td>98.3±0.6</td><td>91.0 ± 1.4</td><td>98.9 ± 0.5</td></tr><tr><td>Birdsong detection</td><td>81.3± 0.9</td><td>82.3±0.9</td><td>78.8±0.9</td><td>81.9 ±0.9</td></tr><tr><td>Emotion recognition</td><td>24.1 ± 2.1</td><td>24.4±2.1</td><td>26.2 ± 2.1</td><td>31.9 ± 2.3</td></tr><tr><td>Speaker Id. (LBS)</td><td>100.0 ± 0.0</td><td>100.0± 0.0</td><td>100.0 ± 0.0</td><td>100.0 ± 0.0</td></tr><tr><td>Music (instrument)</td><td>70.7 ± 0.6</td><td>66.3± 0.6</td><td>67.4± 0.6</td><td>70.2 ±0.6</td></tr><tr><td>Music (pitch)</td><td>88.5 ± 0.4</td><td>86.4 ± 0.4</td><td>81.2 ± 0.5</td><td>88.6 ± 0.4</td></tr><tr><td>Speech commands</td><td>93.6 ± 0.3</td><td>89.5 ± 0.4</td><td>91.4 ± 0.4</td><td>93.6 ±0.3</td></tr><tr><td>Language Id.</td><td>64.9 ±0.5</td><td>58.9 ± 0.5</td><td>60.8 ± 0.5</td><td>69.6 ± 0.5</td></tr><tr><td>Average</td><td>77.8±0.7</td><td>75.8 ±0.7</td><td>74.6± 0.8</td><td>79.3 ± 0.7</td></tr></table>
+
+Table 4: Test AUC and d-prime ( $\pm$ standard deviation over three runs) on Audioset, with the number of learnable parameters per frontend.   
+
+<table><tr><td></td><td></td><td colspan="2">EfficientNetB0</td><td colspan="2">CNN14 (ours)</td><td colspan="2">CNN14 (Kong et al., 2019)</td></tr><tr><td>Frontend</td><td>#Params</td><td>AUC</td><td>d-prime</td><td>AUC</td><td>d-prime</td><td>AUC</td><td>d-prime</td></tr><tr><td>Mel</td><td>0</td><td>0.968 ± .001</td><td>2.61± .02</td><td>0.972 ± .000</td><td>2.71± .01</td><td>0.973</td><td>2.73</td></tr><tr><td>Mel-PCEN</td><td>256</td><td>0.967 ± .000</td><td>2.60± .01</td><td>0.973± .000</td><td>2.72 ± .00</td><td>-</td><td>-</td></tr><tr><td>Wavegram</td><td>300k</td><td>0.958 ± .000</td><td>2.44± .00</td><td>0.961 ± .001</td><td>2.50± .02</td><td>0.968</td><td>2.61</td></tr><tr><td>TD-fbanks</td><td>51k</td><td>0.965 ± .001</td><td>2.57± .01</td><td>0.972 ± .000</td><td>2.70±.00</td><td>-</td><td>-</td></tr><tr><td>SincNet</td><td>256</td><td>0.961 ± .000</td><td>2.48±.00</td><td>0.970 ± .000</td><td>2.66 ± .01</td><td>=</td><td>-</td></tr><tr><td>SincNet+</td><td>448</td><td>0.966 ± .002</td><td>2.58± .04</td><td>0.973± .001</td><td>2.71± .01</td><td></td><td>=</td></tr><tr><td>LEAF</td><td>448</td><td>0.968 ± .001</td><td>2.63± .01</td><td>0.974± .000</td><td>2.74± .01</td><td></td><td></td></tr></table>
+
+$$
+\mathcal { L } = \sum _ { i = 1 } ^ { B } \sum _ { k = 1 } ^ { K } \mathcal { L } _ { k } \left( h _ { \theta _ { k } } \left( g _ { \theta } ( \mathcal { F } _ { \psi } ( x _ { i } ^ { k _ { i } } ) \right) , y _ { i } ^ { k _ { i } } \right) \delta ( k _ { i } , k ) ,
+$$
+
+where $\theta$ and $\psi$ represent the shared parameters of the encoder and frontend respectively, $\theta _ { k }$ , $k =$ $1 , \ldots , K$ the task-specific parameters of the heads $h _ { \theta _ { k } } ( \cdot )$ , and $\delta$ is the Kronecker delta function.
+
+We use the same set of tasks described in Section 4.1 with one exception, replacing VoxCeleb with Librispeech for speaker identification. As illustrated in Table A.1, VoxCeleb has much more classes $( \approx 1 2 0 0 )$ than any other task. This creates an imbalance in the number of parameters in the heads, making training significantly slower and reducing the accuracy on all other tasks, regardless of the frontend. Table 3 reports the accuracy obtained on each task, for all the frontends. LEAF shows the best overall performance while matching or outperforming all other methods on every tasks. We repeated the bootstrap analysis (Figure A.2) to evaluate the statistical significance of these results with respect to the choice of the datasets and observed the following p-values: $p _ { \mathrm { M e l } } = 0 . 0 4 8$ , $p _ { \mathrm { T D } } .$ -fbanks $< 1 0 ^ { - 5 }$ , $p _ { \mathrm { S i n c N e t } } = 1 0 ^ { - 5 }$ . To the best of our knowledge, it is the first time a learnable frontend is shown to outperform mel-filterbanks over several tasks with a unique parametrization.
+
+# 4.3 MULTI-LABEL CLASSIFICATION ON AUDIOSET
+
+Table 4 shows the performance (averaged over three runs) of the different frontends on Audioset (Gemmeke et al., 2017), a large-scale multi-label dataset of sounds of all categories, described by an ontology of 527 classes. Audioset examples are weakly labelled with one or more positive labels, so we evaluate with the standard metric of this dataset, the balanced d-prime, a non-linear transformation of the AUC averaged uniformly across all classes. EfficientNetB0 trained with LEAF achieves a d-prime of 2.63, outperforming the level achieved when using mel-filterbanks (d-prime: 2.61) or other frontends. We compare this result with the state-of-the-art PANN model (Kong et al., 2019), which reports a d-prime of 2.73 when trained on mel-filterbanks. Kong et al. (2019) also train a learnable “Wavegram” frontend made of 9 layers of 1D- and 2D- convolutions, for a total of $3 0 0 \mathrm { k }$ parameters, reporting a d-prime equal to 2.61. EfficientNetB0 on LEAF thus outperforms this system, while having a frontend with 670x fewer parameters, and a considerably smaller encoder. To confirm these results, we also train EfficientNetB0 on the Wavegram and get similar findings.
+
+All these findings are replicated when replacing EfficientNetB0 with our implementation of CNN14: even though the gap between LEAF and baselines reduces as the scores get higher, CNN14 on LEAF matches the current state-of-the-art on AudioSet. To conclude these experiments and show that individual components of LEAF can benefit other frontends, we replace the max-pooling of SincNet with our Gaussian lowpass filter, and LayerNorm (Ba et al., 2016) with the proposed sPCEN. This version, named “SincNet+” in Table 4, significantly outperforms the original version.
+
+4.4 ANALYSIS OF LEARNED FILTERS, POOLING AND COMPRESSION
+
+Figure A.3 illustrates the center frequencies learned by the Gabor filtering layer of LEAF on AudioSet, and compares them to those of mel-filterbanks. At a high level, these filters do not deviate much from their mel-scale initialization. On the one hand, this indicates that the mel-scale is a strong initialization, a result consistent with previous work (Sainath et al., 2015; Zeghidour et al., 2018b). On the other hand, there are differences at both ends of the range, with LEAF covering a wider range of frequencies. For example, the lowest frequency filter is centered around $6 0 \mathrm { H z }$ , as opposed to $1 0 0 \mathrm { H z }$ for mel-filterbanks. We believe that is one of the reasons that explain the out-performance of LEAF on Audioset, as it focuses on a more appropriate frequency range to represent the underlying audio events. Figure A.4 shows the learned Gaussian lowpass filters at convergence. We see that they all deviate towards a larger frequency bandwidth (characterized by a smaller standard deviation in the time domain), and that each filter has a different bandwidth, which confirms the utility of using depthwise pooling. Figure A.5 shows the learned exponents $r _ { n }$ (initialized at 2.0) and smoothing coefficients $s _ { n }$ (initialized at 0.04) of sPCEN, ordered by filter index. The exponents are spread in [1.9, 2.6], which shows the importance of learning per-channel exponents, as well as the appropriate choice of using a fixed cubic root in previous work (Lyons & Paliwal, 2008), as an alternative to log-compression. Learning per-channel smoothing coefficients also allows deviating from the initialization. Interestingly, most filters keep a low coefficient (slowly moving average), except for the filter with the highest frequency, which has a significantly faster moving average $( s { \approx } 0 . 1 5 )$ .
+
+# 4.5 ROBUSTNESS TO NOISE
+
+We compare the robustness of LEAF and mel-filterbanks to synthetic noise, on the Speech Commands dataset. To do so, we artificially add Gaussian noise to the waveforms both during training and evaluation, with different gains to obtain a Signal-to-Noise Ratio (SNR) from $+ \mathrm { i n f }$ (no noise) to $- 5 \mathrm { d B }$ . Figure A.6 shows that while performance (averaged over three runs) degrades for all models as SNR decreases, LEAF is more resilient than mel-filterbanks. In particular, when using a logarithmic compression, the Gabor 1-D convolution and Gaussian pooling of LEAF maintain a significantly higher accuracy than mel-filterbanks. Using PCEN has an even higher impact on performance when using mel-filterbanks, the best results being obtained with LEAF $^ +$ PCEN.
+
+# 5 CONCLUSION
+
+In this work we introduce LEAF, a fully learnable frontend for audio classification as an alternative to using handcrafted mel-filterbanks. We demonstrate over a large range of tasks that our model is a good drop-in replacement to these features with no adjustment to the task at hand, and can even learn a single set of parameters for general-purpose audio classification while outperforming previously proposed learnable frontends. In future work, we will move yet a step forward in removing handcrafted biases from the model. In particular, our model still relies on an underlying convolutional architecture, with fixed filter length and stride. Learning these important parameters directly from data would allow for an easier generalization across tasks with various sampling rates and frequency content. Moreover, we believe that the general principle of learning to filter, pool and compress can benefit the analysis of non-audio signals, such as seismic data or physiological recordings.
+
+# 6 ACKNOWLEDGMENTS
+
+Authors thank Dick Lyon, Vincent Lostanlen, Matt Harvey, and Alex Park for helpful discussions. Authors are also thankful to Julie Thomas for helping with the design of Figure 1. Finally, authors thank the reviewers of ICLR 2021 for their feedback that helped improving the quality of this work.
+
+# REFERENCES
+
+Joakim Anden and St ´ ephane Mallat. Deep scattering spectrum. ´ IEEE Transactions on Signal Processing, 62(16):4114–4128, 2014.
+
+Blaise Aguera y Arcas, Beat Gfeller, Ruiqi Guo, Kevin Kilgour, Sanjiv Kumar, James Lyon, Julian ¨ Odell, Marvin Ritter, Dominik Roblek, Matthew Sharifi, and Mihajlo Velimirovic. Now Playing: ´ Continuous low-power music recognition. Technical report, nov 2017. URL http://arxiv. org/abs/1711.10958.
+
+Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016.
+
+Randall Balestriero, Romain Cosentino, Herve Glotin, and Richard Baraniuk. Spline filters for ´ end-to-end deep learning. In International Conference on Machine Learning, pp. 364–373, 2018.
+
+Eric Battenberg, Rewon Child, Adam Coates, Christopher Fougner, Yashesh Gaur, Jiaji Huang, Heewoo Jun, Ajay Kannan, Markus Kliegl, Atul Kumar, et al. Reducing bias in production speech models. arXiv preprint arXiv:1705.04400, 2017.
+
+Houwei Cao, David G Cooper, Michael K Keutmann, Ruben C Gur, Ani Nenkova, and Ragini Verma. CREMA-D: Crowd-sourced emotional multimodal actors dataset. IEEE transactions on affective computing, 5(4):377–390, 2014.
+
+Steven Davis and Paul Mermelstein. Comparison of parametric representations for monosyllabic word recognition in continuously spoken sentences. IEEE transactions on acoustics, speech, and signal processing, 28(4):357–366, 1980.
+
+Bradley Efron and Robert J. Tibshirani. An Introduction to the Bootstrap. Number 57 in Monographs on Statistics and Applied Probability. Chapman & Hall/CRC, Boca Raton, Florida, USA, 1993.
+
+Jesse Engel, Cinjon Resnick, Adam Roberts, Sander Dieleman, Douglas Eck, Karen Simonyan, and Mohammad Norouzi. Neural Audio Synthesis of Musical Notes with WaveNet Autoencoders. Technical report, apr 2017. URL http://arxiv.org/abs/1704.01279.
+
+Tiago H Falk and Wai-Yip Chan. Modulation spectral features for robust far-field speaker identification. IEEE Transactions on Audio, Speech, and Language Processing, 18(1):90–100, 2009.
+
+Gustav Theodor Fechner, Davis H Howes, and Edwin Garrigues Boring. Elements of psychophysics, volume 1. Holt, Rinehart and Winston New York, 1966.
+
+Dennis Gabor. Theory of communication. part 1: The analysis of information. Journal of the Institution of Electrical Engineers-Part III: Radio and Communication Engineering, 93(26):429– 441, 1946.
+
+Jort F Gemmeke, Daniel PW Ellis, Dylan Freedman, Aren Jansen, Wade Lawrence, R Channing Moore, Manoj Plakal, and Marvin Ritter. Audio set: An ontology and human-labeled dataset for audio events. In 2017 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 776–780. IEEE, 2017.
+
+Donald D. Greenwood. The mel scale’s disqualifying bias and a consistency of pitch-difference equisections in 1956 with equal cochlear distances and equal frequency ratios. Hearing Research, 103:199–224, 1997.
+
+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.
+
+Toni Heittola, Annamaria Mesaros, and Tuomas Virtanen. TUT Urban Acoustic Scenes 2018, Development dataset, April 2018. URL https://doi.org/10.5281/zenodo.1228142.
+
+Shawn Hershey, Sourish Chaudhuri, Daniel P.W. Ellis, Jort F Gemmeke, Aren Jansen, R Channing Moore, Manoj Plakal, Devin Platt, Rif A Saurous, Bryan Seybold, Malcolm Slaney, Ron J Weiss, and Kevin Wilson. CNN architectures for large-scale audio classification. In ICASSP, IEEE International Conference on Acoustics, Speech and Signal Processing - Proceedings, pp. 131– 135, 2017. ISBN 9781509041176. doi: 10.1109/ICASSP.2017.7952132.
+
+Geoffrey Hinton, Li Deng, Dong Yu, George E Dahl, Abdel-rahman Mohamed, Navdeep Jaitly, Andrew Senior, Vincent Vanhoucke, Patrick Nguyen, Tara N Sainath, et al. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal processing magazine, 29(6):82–97, 2012.
+
+Yedid Hoshen, Ron Weiss, and Kevin W Wilson. Speech acoustic modeling from raw multichannel waveforms. In International Conference on Acoustics, Speech, and Signal Processing, 2015.
+
+Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 4700–4708, 2017.
+
+Navdeep Jaitly and Geoffrey Hinton. Learning a better representation of speech soundwaves using restricted boltzmann machines. In 2011 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 5884–5887. IEEE, 2011.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Qiuqiang Kong, Yin Cao, T. Iqbal, Yuxuan Wang, Wenwu Wang, and Mark D. Plumbley. Panns: Large-scale pretrained audio neural networks for audio pattern recognition. ArXiv, abs/1912.10211, 2019.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012.
+
+V. Lostanlen, J. Salamon, M. Cartwright, B. McFee, A. Farnsworth, S. Kelling, and J. P. Bello. Per-channel energy normalization: Why and how. IEEE Signal Processing Letters, 26(1):39–43, 2019.
+
+Vincent Lostanlen, Justin Salamon, Andrew Farnsworth, Steve Kelling, and Juan Pablo Bello. Birdvox-full-night: A dataset and benchmark for avian flight call detection. In 2018 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 266–270. IEEE, 2018.
+
+Yi Luo and Nima Mesgarani. Conv-tasnet: Surpassing ideal time-frequency magnitude masking for speech separation. IEEE/ACM Trans. Audio, Speech & Language Processing, 27(8):1256–1266, 2019.
+
+Yi Luo, Zhuo Chen, and Takuya Yoshioka. Dual-path rnn: efficient long sequence modeling for time-domain single-channel speech separation. arXiv preprint arXiv:1910.06379, 2019.
+
+James G Lyons and Kuldip K Paliwal. Effect of compressing the dynamic range of the power spectrum in modulation filtering based speech enhancement. In Ninth Annual Conference of the International Speech Communication Association, 2008.
+
+Nelson Mogran, Herve Bourlard, and Hynek Hermansky. Automatic speech recognition: An audi- ´ tory perspective. In Speech processing in the auditory system, pp. 309–338. Springer, 2004.
+
+Arsha Nagrani, Joon Son Chung, and Andrew Zisserman. Voxceleb: A large-scale speaker identification dataset. Interspeech 2017, Aug 2017. doi: 10.21437/interspeech.2017-950. URL http://dx.doi.org/10.21437/Interspeech.2017-950.
+
+Paul-Gauthier Noe, Titouan Parcollet, and Mohamed Morchid. Cgcnn: Complex gabor convolu- ´ tional neural network on raw speech. ICASSP 2020 - 2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 7724–7728, 2020.
+
+D. O’Shaughnessy. Speech communication $:$ human and machine. 1987.
+
+Dimitri Palaz, Ronan Collobert, and Mathew Magimai Doss. Estimating phoneme class conditional probabilities from raw speech signal using convolutional neural networks. arXiv preprint arXiv:1304.1018, 2013.
+
+Dimitri Palaz, Mathew Magimai Doss, and Ronan Collobert. Convolutional neural networks-based continuous speech recognition using raw speech signal. In 2015 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 4295–4299. IEEE, 2015.
+
+Manuel Pariente, Samuele Cornell, Antoine Deleforge, and Emmanuel Vincent. Filterbank design for end-to-end speech separation. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 6364–6368. IEEE, 2020.
+
+Daniel S Park, William Chan, Yu Zhang, Chung-Cheng Chiu, Barret Zoph, Ekin D Cubuk, and Quoc V Le. Specaugment: A simple data augmentation method for automatic speech recognition. arXiv preprint arXiv:1904.08779, 2019.
+
+Mirco Ravanelli and Yoshua Bengio. Speaker recognition from raw waveform with sincnet. In 2018 IEEE Spoken Language Technology Workshop (SLT), pp. 1021–1028. IEEE, 2018.
+
+Shauna Revay and Matthew Teschke. Multiclass language identification using deep learning on spectral images of audio signals. CoRR, abs/1905.04348, 2019. URL http://arxiv.org/ abs/1905.04348.
+
+T. Sainath, Brian Kingsbury, Abdel rahman Mohamed, and B. Ramabhadran. Learning filter banks within a deep neural network framework. 2013 IEEE Workshop on Automatic Speech Recognition and Understanding, pp. 297–302, 2013.
+
+Tara N Sainath, Ron J Weiss, Andrew Senior, Kevin W Wilson, and Oriol Vinyals. Learning the speech front-end with raw waveform cldnns. In Sixteenth Annual Conference of the International Speech Communication Association, 2015.
+
+Jan Schluter and Bernhard Lehner. Zero-mean convolutions for level-invariant singing voice detec- ¨ tion. In ISMIR, 2018.
+
+Ralf Schluter, Ilja Bezrukov, Hermann Wagner, and Hermann Ney. Gammatone features and feature combination for large vocabulary speech recognition. In 2007 IEEE International Conference on Acoustics, Speech and Signal Processing-ICASSP’07, volume 4, pp. IV–649. IEEE, 2007.
+
+Steffen Schneider, Alexei Baevski, Ronan Collobert, and Michael Auli. wav2vec: Unsupervised pre-training for speech recognition. arXiv preprint arXiv:1904.05862, 2019.
+
+Andrew Senior, Hasim Sak, Felix de Chaumont Quitry, Tara N. Sainath, and Kanishka Rao. Acoustic modelling with cd-ctc-smbr lstm rnns. In ASRU, 2015.
+
+Stanley S Stevens and John Volkmann. The relation of pitch to frequency: A revised scale. The American Journal of Psychology, 53(3):329–353, 1940.
+
+Dan Stowell, — Mike Wood, — Hanna Pamuła, Yannis Stylianou, and Herve Glotin. Automatic ´ acoustic detection of birds through deep learning: the first Bird Audio Detection challenge. Technical report, 2018. URL https://arxiv.org/pdf/1807.05812.pdf.
+
+Gabriel Synnaeve, Qiantong Xu, Jacob Kahn, Edouard Grave, Tatiana Likhomanenko, Vineel Pratap, Anuroop Sriram, Vitaliy Liptchinsky, and Ronan Collobert. End-to-end asr: from supervised to semi-supervised learning with modern architectures. arXiv preprint arXiv:1911.08460, 2019.
+
+Mingxing Tan and Quoc V. Le. Efficientnet: Rethinking model scaling for convolutional neural networks. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, volume 97 of Proceedings of Machine Learning Research, pp. 6105–6114. PMLR, 2019. URL http://proceedings.mlr.press/v97/tan19a.html.
+
+Samuel Thomas, Sriram Ganapathy, and Hynek Hermansky. Hilbert envelope based features for far-field speech recognition. In International Workshop on Machine Learning for Multimodal Interaction, pp. 119–124. Springer, 2008.
+
+Andros Tjandra, Sakriani Sakti, and Satoshi Nakamura. Attention-based wav2text with feature transfer learning. In 2017 IEEE automatic speech recognition and understanding workshop (ASRU), pp. 309–315. IEEE, 2017.
+
+S. Umesh, L. Cohen, and D. Nelson. Fitting the mel scale. 1999 IEEE International Conference on Acoustics, Speech, and Signal Processing. Proceedings. ICASSP99 (Cat. No.99CH36258), 1: 217–220 vol.1, 1999.
+
+Jesus Villalba, Nanxin Chen, David Snyder, Daniel Garcia-Romero, Alan McCree, Gregory Sell, ´ Jonas Borgstrom, Leibny Paola Garc´ıa-Perera, Fred Richardson, Reda Dehak, et al. State-of-the-´ art speaker recognition with neural network embeddings in nist sre18 and speakers in the wild evaluations. Computer Speech & Language, 60:101026, 2020.
+
+Yuxuan Wang, Pascal Getreuer, Thad Hughes, Richard F Lyon, and Rif A Saurous. Trainable frontend for robust and far-field keyword spotting. In 2017 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 5670–5674. IEEE, 2017.
+
+Pete Warden. Speech Commands: A Dataset for Limited-Vocabulary Speech Recognition. Technical report, 2018. URL https://arxiv.org/pdf/1804.03209.pdf.
+
+Neil Zeghidour, Nicolas Usunier, Iasonas Kokkinos, Thomas Schatz, Gabriel Synnaeve, and Emmanuel Dupoux. Learning filterbanks from raw speech for phone recognition. In 2018 IEEE international conference on acoustics, speech and signal Processing (ICASSP), pp. 5509–5513. IEEE, 2018a.
+
+Neil Zeghidour, Nicolas Usunier, Gabriel Synnaeve, Ronan Collobert, and Emmanuel Dupoux. Endto-end speech recognition from the raw waveform. Interspeech, abs/1806.07098, 2018b.
+
+Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. arXiv preprint arXiv:1710.09412, 2017.
+
+Richard Zhang. Making convolutional networks shift-invariant again. arXiv preprint arXiv:1904.11486, 2019.
+
+# A APPENDIX
+
+Table A.1: Datasets used in the experiments. Default train/test splits are always adopted.   
+
+<table><tr><td>Task</td><td>Name</td><td>Classes</td><td>Train examples</td><td>Test examples</td></tr><tr><td>Audio events</td><td>Audioset</td><td>527</td><td>1,832,720</td><td>17,695</td></tr><tr><td>Acoustic scenes</td><td>TUTUrban 2018</td><td>10</td><td>7,829</td><td>810</td></tr><tr><td>Birdsong detection</td><td>DCASE2018</td><td>2</td><td>32,129</td><td>3,561</td></tr><tr><td>Emotion recognition</td><td>Crema-D</td><td>6</td><td>5,146</td><td>820</td></tr><tr><td>Speaker Id.</td><td>Voxceleb</td><td>1,251</td><td>138,361</td><td>8,249</td></tr><tr><td>Speaker Id.</td><td>Librispeech</td><td>251</td><td>25,740</td><td>2,799</td></tr><tr><td>Music (instrument)</td><td>Nsynth</td><td>11</td><td>289,205</td><td>12,678</td></tr><tr><td>Music (pitch)</td><td>Nsynth</td><td>128</td><td>289,205</td><td>12,678</td></tr><tr><td>Speech commands</td><td>Speech commands</td><td>35</td><td>84,771</td><td>10,700</td></tr><tr><td>Language Id.</td><td>Voxforge</td><td>6</td><td>126,610</td><td>18,378</td></tr></table>
+
+![](images/ea4a0adef0aafc6b4d3ab1101a9bf0e45645b0595fec97d9e4f72d1177d8553a.jpg)  
+Figure A.1: Distribution of the difference between the accuracy $( \% )$ obtained with LEAF and each of the other frontends when sampling 8 datasets with replacement, in the single task setting.
+
+![](images/c982f096032ab915218b552f395fb370198ea87152f61446ee0cbc3d54f1b9fb.jpg)  
+Figure A.2: Distribution of the difference between the accuracy obtained with LEAF and each of the other frontends when sampling 8 datasets with replacement, in the multi-task setting.
+
+![](images/96826f630f45395be1f7b24c86d48890d3d93821d4871cadb522f6ecc5a33d0e.jpg)  
+Figure A.3: Comparison between the filters learned by LEAF and the mel scale.
+
+![](images/a2bc369c176eaa4408f7a1cb1cd59d118888305dbfe79904f3466db07f0015e1.jpg)  
+Figure A.4: Learned Gaussian lowpass filters of LEAF on AudioSet. The dotted line represents the initialization, identical for all filters.
+
+![](images/6acfe308d30803c48b9553683f6462e63c3c14d2210d26e66074c4b30d5ccb69.jpg)  
+Figure A.5: Values of learned sPCEN parameters of LEAF trained on AudioSet. The dotted lines represent the initialization, identical for all filters.
+
+![](images/bc4b9e48e7ce47447f4ec2cae15d1c700194a7a5b2126f74d97a4cf6ff063ef4.jpg)  
+Figure A.6: Test accuracy $( \% )$ on the test set of the Speech Commands dataset with varying SNR.

parse/train/jM76BCb6F9m/jM76BCb6F9m_content_list.json

@@ -0,0 +1,1668 @@
+[
+    {
+        "type": "text",
+        "text": "LEAF: A LEARNABLE FRONTEND FOR AUDIO CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            732,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neil Zeghidour, Olivier Teboul, Felix de Chaumont Quitry & Marco Tagliasacchi ´ Google Research {neilz, oliviert, fcq, mtagliasacchi}@google.com ",
+        "bbox": [
+            184,
+            170,
+            746,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            250,
+            544,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Mel-filterbanks are fixed, engineered audio features which emulate human perception and have been used through the history of audio understanding up to today. However, their undeniable qualities are counterbalanced by the fundamental limitations of handmade representations. In this work we show that we can train a single learnable frontend that outperforms mel-filterbanks on a wide range of audio signals, including speech, music, audio events and animal sounds, providing a general-purpose learned frontend for audio classification. To do so, we introduce a new principled, lightweight, fully learnable architecture that can be used as a drop-in replacement of mel-filterbanks. Our system learns all operations of audio features extraction, from filtering to pooling, compression and normalization, and can be integrated into any neural network at a negligible parameter cost. We perform multi-task training on eight diverse audio classification tasks, and show consistent improvements of our model over mel-filterbanks and previous learnable alternatives. Moreover, our system outperforms the current state-of-the-art learnable frontend on Audioset, with orders of magnitude fewer parameters. ",
+        "bbox": [
+            233,
+            284,
+            764,
+            491
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            522,
+            336,
+            537
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Learning representations by backpropagation in deep neural networks has become the standard in audio understanding, ranging from automatic speech recognition (ASR) (Hinton et al., 2012; Senior et al., 2015) to music information retrieval (Arcas et al., 2017), as well as animal vocalizations (Lostanlen et al., 2018) and audio events (Hershey et al., 2017; Kong et al., 2019). Still, a striking constant along the history of audio classification is the mel-filterbanks, a fixed, hand-engineered representation of sound. Mel-filterbanks first compute a spectrogram, using the squared modulus of the short-term Fourier transform (STFT). Then, the spectrogram is passed through a bank of triangular bandpass filters, spaced on a logarithmic scale (the mel-scale) to replicate the non-linear human perception of pitch (Stevens & Volkmann, 1940). Eventually, the resulting coefficients are passed through a logarithm compression, to replicate our non-linear sensitivity to loudness (Fechner et al., 1966). This approach of drawing inspiration from the human auditory system to design features for machine learning has been historically successful (Davis & Mermelstein, 1980; Mogran et al., 2004). Moreover, decades after the design of mel-filterbanks, Anden & Mallat ´ (2014) showed that they coincidentally exhibit desirable mathematical properties for representation learning, in particular shift-invariance and stability to small deformations. Hence, both from an auditory and a machine learning perspective, mel-filterbanks represent strong audio features. ",
+        "bbox": [
+            174,
+            556,
+            825,
+            776
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, the design of mel-filterbanks is also flawed by biases. First, not only has the mel-scale been revised multiple times (O’Shaughnessy, 1987; Umesh et al., 1999), but also the auditory experiments that led their original design could not be replicated afterwards (Greenwood, 1997). Similarly, better alternatives to log-compression have been proposed, like cubic root for speech enhancement (Lyons & Paliwal, 2008) or 10th root for ASR (Schluter et al., 2007). Moreover, even though matching human perception provides good inductive biases for some application domains, e.g., ASR or music understanding, these biases may also be detrimental, e.g. for tasks that require fine-grained resolution at high frequencies. Finally, the recent history of other fields like computer vision, in which the rise of deep learning methods has allowed learning representations from raw pixels rather than from engineered features (Krizhevsky et al., 2012), inspired us to take the same path. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/003a0d0b590f2740367e849212a5e09db4a86bbac1184aaf4028bf9d7416e280.jpg",
+        "image_caption": [
+            "Figure 1: Breakdown of the computation of mel-filterbanks, Time-Domain filterbanks, SincNet, and the proposed LEAF frontend. Orange boxes are fixed, while computations in blue boxes are learnable. Grey boxes represent activation functions. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            102,
+            820,
+            246
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "These observations motivated replacing mel-filterbanks with learnable neural layers, ranging from standard convolutional layers (Palaz et al., 2015) to dilated convolutions (Schneider et al., 2019), as well as structured filters exploiting the characteristics of known filter families, such as Gammatone (Sainath et al., 2015), Gabor (Zeghidour et al., 2018a; Noe et al.´ , 2020), Sinc (Ravanelli & Bengio, 2018; Pariente et al., 2020) or Spline (Balestriero et al., 2018) filters. While tasks such as speech separation have already successfully adopted learnable frontends (Luo & Mesgarani, 2019; Luo et al., 2019), we observe that most state-of-the art approaches for audio classification (Kong et al., 2019), ASR (Synnaeve et al., 2019) and speaker recognition (Villalba et al., 2020) still employ mel-filterbanks as input features, regardless of the backbone architecture. ",
+        "bbox": [
+            174,
+            334,
+            825,
+            459
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we argue that a credible alternative to mel-filterbanks for classification should be evaluated across many tasks, and propose the first extensive study of learnable frontends for audio over a wide and diverse range of audio signals, including speech, music, audio events, and animal sounds. By breaking down mel-filterbanks into three components (filtering, pooling, compression/normalization), we propose LEAF, a novel frontend that is fully learnable in all its operations, while being controlled by just a few hundred parameters. In a multi-task setting over 8 datasets, we show that we can learn a single set of parameters that outperforms mel-filterbanks, as well as previously proposed learnable alternatives. Moreover, these findings are replicated when training a different model for each individual task. We also confirm these results on a challenging, large-scale benchmark: classification on Audioset (Gemmeke et al., 2017). In addition, we show that the general inductive bias of our frontend (i.e., learning bandpass filters, lowpass filtering before downsampling, learning a per-channel compression) is general enough to benefit other systems, and propose a new, improved version of SincNet (Ravanelli & Bengio, 2018). Our code is publicly available1. ",
+        "bbox": [
+            174,
+            467,
+            825,
+            646
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            667,
+            341,
+            684
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the last decade, several works addressed the problem of learning the audio frontend, as an alternative to mel-filterbanks. The first notable contributions in this field emerged for ASR, with Jaitly & Hinton (2011) pretraining Restricted Boltzmann Machines from the waveform, and Palaz et al. (2013) training a hybrid DNN-HMM model, replacing mel-filterbanks by several layers of convolution. However, these alternatives, as well as others proposed more recently (Tjandra et al., 2017; Schneider et al., 2019), are composed of many layers, which makes a fair comparison with melfilterbanks difficult. In the following section, we focus on frontends that provide a lightweight, drop-in replacement to mel-filterbanks, with comparable capacity. ",
+        "bbox": [
+            174,
+            700,
+            825,
+            811
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 LEARNING FILTERS FROM WAVEFORMS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            830,
+            483,
+            843
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A first attempt at learning the filters of mel-filterbanks was proposed by Sainath et al. (2013), where a filterbank is initialized using the mel-scale and then learned together with the rest of the network, taking a spectrogram as input. Instead, Sainath et al. (2015) and Hoshen et al. (2015) later proposed to learn convolutional filters directly from raw waveforms, initialized with Gammatone filters (Schluter et al., 2007). In the same spirit, Zeghidour et al. (2018a) used the scattering transform approximation of mel-filterbanks (Anden & Mallat ´ , 2014) to propose the time-domain filterbanks, a learnable frontend that approximates mel-filterbanks at initialization and can then be learned without constraints (see Figure 1). More recently, the SincNet (Ravanelli & Bengio, 2018) model was proposed, which computes a convolution with sine cardinal filters, a non-linearity and a max-pooling operator (see Figure 1), as well as a variant using Gabor filters (Noe et al. ´ , 2020). ",
+        "bbox": [
+            176,
+            856,
+            825,
+            898
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We take inspiration from these works to design a new learnable filtering layer. As detailed in Section 3.1.2, we parametrize a complex-valued filtering layer with Gabor filters. Gabor filters are optimally localized in time and frequency (Gabor, 1946), unlike Sinc filters that require using a window function (Ravanelli & Bengio, 2018). Moreover, unlike Noe et al. ´ (2020), who use complex-valued layers in the rest of the network, we describe in Section 3.1.2 how using a squared modulus not only brings back the signal to the real-valued domain (leading to compatibility with standard architectures), but also performs shift-invariant Hilbert envelope extraction. Zeghidour et al. (2018a) also apply a squared modulus non-linearity, however as described in Section 3.1.1, training unconstrained filters can lead to overfitting and stability issues, which we solve with our approach. ",
+        "bbox": [
+            174,
+            208,
+            825,
+            333
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 LEARNING THE COMPRESSION AND THE NORMALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            351,
+            614,
+            364
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The problem of learning a compression and/or normalization function has received less attention in the past literature. A notable contribution is the Per-Channel Energy Normalization (PCEN) (Wang et al., 2017; Lostanlen et al., 2019), which was originally proposed for keyword spotting, outperforming log-compression. Later, Battenberg et al. (2017) and Lostanlen et al. (2018) confirmed the advantages of PCEN, respectively for large scale ASR and animal bioacoustics. However, these previous works learn a compression on top of fixed mel-filterbanks. Instead, in this work we propose a new version of PCEN and show for the first time that combining learnable filters, learnable pooling, and learnable compression and normalization outperforms all other approaches. ",
+        "bbox": [
+            174,
+            376,
+            825,
+            487
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            506,
+            267,
+            522
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $x \\in \\mathbb { R } ^ { T }$ denote a one-dimensional waveform of $T$ samples, available at the sampling frequency $F _ { s }$ [Hz]. We decompose the frontend into a sequence of three components: i) filtering, which passes $x$ through a bank of bandpass filters followed by a non-linearity, operating at the original sampling rate $F _ { s }$ ; ii) pooling, which decimates the signal to reduce its temporal resolution; iii) compression/normalization, which applies a non-linearity to reduce the dynamic range. Overall, the frontend can be represented as a function $\\mathcal { F } _ { \\psi } : \\mathbb { R } ^ { T }  \\mathbb { R } ^ { M \\times N }$ , which maps the input waveform to a 2-dimensional feature space, where $M$ denotes the number of temporal frames (typically $M < T$ ), $N$ the number of feature channels (which might correspond to frequency bins) and $\\psi$ the frontend parameters. The features computed by the frontend are then fed to a model $g _ { \\theta } ( \\cdot )$ parametrized by $\\theta$ . The frontend and the model parameters are estimated by solving a supervised classification problem: ",
+        "bbox": [
+            173,
+            536,
+            825,
+            678
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a7a2888dd1f85671fe2530fe0140f4515e378b6c98a176f98cc04b02c1b2923f.jpg",
+        "text": "$$\n\\theta ^ { * } , \\psi ^ { * } = \\underset { \\theta , \\psi } { \\arg \\operatorname* { m i n } } E _ { ( x , y ) \\in \\mathcal { D } } \\ : \\mathcal { L } \\big ( g _ { \\theta } ( \\mathcal { F } _ { \\psi } ( x ) ) , y \\big ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            681,
+            648,
+            708
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $( x , y )$ are samples in a labelled dataset $\\mathcal { D }$ and $\\mathcal { L }$ is a loss function. Our goal is to learn the frontend parameters $\\psi$ end-to-end with the model parameters $\\theta$ . To achieve this, it is necessary to make all the frontend components learnable, so that we can solve the optimization problem in equation 1 with gradient descent. In the following we detail the design choices of each component. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            770
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 FILTERING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            786,
+            290,
+            800
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The first block of the learnable frontend takes $x$ as input, and computes a convolution with a bank of complex-valued filters ${ { ( { \\varphi _ { n } } ) } _ { n = 1 \\dots N } }$ , followed by a squared modulus operator, which brings back its output to the real-valued domain. This convolution step has a stride of 1, therefore keeping the input temporal resolution, and outputs the following time-frequency representation: ",
+        "bbox": [
+            174,
+            811,
+            823,
+            868
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5b2ee8f2bd50839e3db65a1a8dfdb9f6fee5a9e83c4291375f1c3910d114b3ec.jpg",
+        "text": "$$\nf _ { n } = | x * \\varphi _ { n } | ^ { 2 } \\in \\mathbb R ^ { T } , \\quad n = 1 , \\dots , N ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            872,
+            629,
+            891
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\varphi _ { n } \\in \\mathbb { C } ^ { W }$ is a complex-valued 1-D filter of length $W$ . It is possible to compute equation 2 without explicitly manipulating complex numbers. As proposed by Zeghidour et al. (2018a), to produce the squared-modulus of a complex-valued convolution with $N$ filters, we compute instead the convolution with $2 N$ real-valued filters $\\tilde { \\varphi } _ { n } , n = 1 , \\ldots , 2 N$ , and perform squared $\\ell _ { 2 }$ -pooling with size 2 and stride 2 along the channel axis to obtain the squared modulus, using adjacent filters as real and imaginary part of $\\varphi _ { n }$ . Formally: ",
+        "bbox": [
+            173,
+            895,
+            828,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/0679ecc25b24fb5cc92b1cd4d1d17b80031e02bd7879db13d3ef013bb9af4fa8.jpg",
+        "image_caption": [
+            "Figure 2: Frequency response of filters at convergence for two parametrizations: normalized 1D filters and Gabor filters, both initialized on a mel scale. We highlight two filters among the 40 of the filterbank: one in yellow in the low frequency range and one in pink at high frequencies. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            104,
+            818,
+            227
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            311,
+            825,
+            367
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/62ca47c7c7d7f81cf4ea99b2caaf8c1400efd301922762deb2f365b8ff3177f9.jpg",
+        "text": "$$\nf _ { n } = | x * \\tilde { \\varphi } _ { 2 n - 1 } | ^ { 2 } + | x * \\tilde { \\varphi } _ { 2 n } | ^ { 2 } \\in \\mathbb { R } ^ { T } , \\quad n = 1 , \\dots , N .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            312,
+            376,
+            686,
+            395
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We explore two different parametrizations for $\\varphi _ { n }$ . One relies on standard fully parametrized convolutional filters while the other makes use of learnable Gabor filters. ",
+        "bbox": [
+            174,
+            410,
+            823,
+            438
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1.1 NORMALIZED 1D-CONVOLUTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            454,
+            462,
+            469
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Inspired by Zeghidour et al. (2018a), the first version of our filtering component is a standard 1D convolution, initialized with a bank of Gabor filters, which approximates the computation of a melfilterbank. Thus, at initialization, the output of the frontend is identical to that of a mel-filterbank, but during training the filters can be learned by backpropagation. In our early experiments, we observed several limitations of this approach. First, due to the unconstrained optimization, these filters not only learn to select frequency bands of interest, but also learn a scaling factor. This might lead to instability during training, because the same form of scaling can be also computed by the filter-wise compression component, which is applied at a later stage in the frontend. We address this issue by applying $\\ell _ { 2 }$ -normalization to the filter coefficients before computing the convolution. Second, the unconstrained parametrization increases the number of degrees of freedom, making training prone to overfitting. The first panel in Figure 2 shows the frequency response of a bank of $N = 4 0$ filters, each parametrized with $W = 4 0 1$ coefficients. We observe that, at convergence, they are widely spread across the frequency axis, and include negative frequencies. Moreover, the filters are very spiky rather than smooth. To alleviate these issues, in the next section we introduce a parametrization based on a bank of Gabor filters, which reduces the number of parameters to learn, while at the same time enforcing during training a stable and interpretable representation. ",
+        "bbox": [
+            174,
+            479,
+            825,
+            702
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1.2 GABOR 1D-CONVOLUTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            718,
+            416,
+            733
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Gabor filters are produced by modulating a Gaussian kernel with a sinusoidal signal. These filters provide several desirable properties. First, they have an optimal trade-off between localization in time and frequency (Gabor, 1946), which makes them a suitable choice for a convolutional network with finite-sized filters. This is in contrast to Sinc filters (Ravanelli & Bengio, 2018), which require using a window function to smooth abrupt variations on each side of the filter. Second, the time and frequency response of Gabor filters have the same functional form, thus leading to interpretable bandpass filters, unlike the unconstrained filters described in the previous section. Finally, Gabor filters are quasi-analytic (i.e., their frequency response is almost zero for negative frequencies) and when combined with the squared modulus the resulting filterbank can be interpreted as a set of subband Hilbert envelopes, which are invariant to small shifts. Due to this desirable property, they have been previously used as (fixed) features for speech and speaker recognition (Falk & Chan, 2009; Thomas et al., 2008). Formally, Gabor filters are parametrized by their center frequencies $( \\eta _ { n } ) _ { n = 1 \\ldots N }$ and inverse bandwidths $( \\sigma _ { n } ) _ { n = 1 \\ldots N }$ as follows: ",
+        "bbox": [
+            174,
+            743,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fb691cf3b2cc2e01a88e85a8cc124622be857e9ef1a7e94ab55075195841884d.jpg",
+        "text": "$$\n\\varphi _ { n } ( t ) = e ^ { i 2 \\pi \\eta _ { n } t } \\frac { 1 } { \\sqrt { 2 \\pi } \\sigma _ { n } } e ^ { - \\frac { t ^ { 2 } } { 2 \\sigma _ { n } ^ { 2 } } } , n = 1 , \\dots , N , t = - W / 2 , \\dots , W / 2 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            254,
+            114,
+            743,
+            148
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The frequency response of $\\varphi _ { n }$ is a Gaussian centered at frequency $\\eta _ { n }$ and of bandwidth $1 / \\sigma _ { n }$ , both expressed in normalized frequency units in $[ - 1 / 2 , + 1 / 2 ]$ . Therefore, learning these parameters allows learning a bank of smooth, quasi-analytic bandpass filters, with controllable center frequency and bandwidth. In practice, to compute the output of the filtering component, we obtain the impulse response of the Gabor filters $\\varphi _ { n } ( t )$ over the range $t = - W / 2 , \\dots , W / 2$ , and convolve these impulse responses with the input waveform. To ensure stability during training, we clip the center frequencies $( \\eta _ { n } ) _ { n = 1 \\ldots N }$ to be in $[ 0 , 1 / 2 ]$ , so that they lie in the positive part of the frequency range.√ √ We also constrain the bandwidths $( \\sigma _ { n } ) _ { n = 1 \\ldots N }$ in the range $[ 4 \\dot { \\sqrt { 2 \\log 2 } } , \\dot { 2 } W \\sqrt { 2 \\log 2 } ]$ , such that the full-width at half-maximum of the frequency response is within $1 / W$ and $1 / 2$ . ",
+        "bbox": [
+            174,
+            159,
+            825,
+            285
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Gabor filters have significantly fewer parameters than the normalized 1D-convolutions described in Section 3.1.1. $N$ filters of length $W$ are described by $2 N$ parameters, $N$ for the center frequencies and $N$ for the bandwidths, against $W \\cdot N$ for a standard 1D-convolution. In particular, when using a window length of $2 5 \\mathrm { m s }$ , operating at a sampling rate of $1 6 \\mathrm { k H z }$ , then $W = 4 0 1$ samples, and Gabor-based filtering accounts for 200 times fewer parameters than their unconstrained alternatives. ",
+        "bbox": [
+            174,
+            291,
+            825,
+            362
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1.3 TIME-FREQUENCY ANALYSIS AND LEARNABLE FILTERS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            378,
+            614,
+            392
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A spectrogram, in linear or mel scale, provides an ordered time-frequency representation: adjacent frames represent consecutive time-steps, while frequencies monotonically increase along the feature axis. A learnable frontend that performs filtering by means of convolution with a set of bandpass filters also preserves ordering along the temporal axis. However, the ordering along the feature axis is unconstrained. This can be problematic when applying subsequent operations that rely on frequency ordering. These include, for example: i) operations that leverage local frequency information, e.g., two-dimensional convolutions, which compute a feature representation based on local time-frequency patches; ii) operations that leverage long-range dependencies along the frequency axis, e.g., to capture the harmonic structure of the underlying signal; and iii) augmentation methods that mask adjacent frequency bands, like SpecAugment (Park et al., 2019). To evaluate the impact of enforcing an explicit ordering of the center frequencies of the learned filters, we compared the result of training a frontend using Gabor filters with or without explicitly enforcing ordering of the center frequencies. Interestingly, we observe that even without an explicit constraint, filters that are ordered at the initialization tend to keep the same ordering throughout training, and that enforcing sorted filters has no effect on the performance. ",
+        "bbox": [
+            174,
+            402,
+            825,
+            609
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 LEARNABLE LOWPASS POOLING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            628,
+            441,
+            642
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The output of the filtering component has the same temporal resolution as the input waveform. The second step of a learnable frontend is to downsample the output of the filterbank to a lower sampling rate, similarly to what happens in the STFT when computing mel-filterbanks. Previous work relied on max-pooling (Sainath et al., 2015; Ravanelli & Bengio, 2018; Noe et al. ´ , 2020), lowpassfiltering (Zeghidour et al., 2018a) or average pooling (Balestriero et al., 2018). Zeghidour et al. (2018b) compare these methods on a speech recognition task and show a systematic improvement when using lowpass filtering instead of max-pooling. More recently, Zhang (2019) showed that in standard 2D convolutional architectures, including ResNet (He et al., 2016) and DenseNet (Huang et al., 2017), a drop-in replacement of max-pooling and average pooling layers with a (fixed) lowpass filter improves the performance for image classification. In the proposed frontend, we extend the pooling layer of Zeghidour et al. (2018a) in two ways. First, while Zeghidour et al. (2018a) adopt a single shared lowpass filter for all input channels, we implement lowpass filtering by means of depthwise convolution, such that each input channel is associated with one lowpass filter. This is useful because each channel in the learnable frontend is characterized by a different bandwidth, and a specific lowpass filter can be learned for each of them. Second, we parametrize these lowpass filters to have a Gaussian impulse response: ",
+        "bbox": [
+            174,
+            655,
+            825,
+            876
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/28c8462ec6afa410f0b86bbb496c9607533199817dc345f744afd01e7b872e1d.jpg",
+        "text": "$$\n\\phi _ { n } ( t ) = \\frac { 1 } { \\sqrt { 2 \\pi } \\sigma _ { n } } e ^ { - \\frac { t ^ { 2 } } { 2 \\sigma _ { n } ^ { 2 } } } , \\quad t = - W / 2 , \\dots , W / 2 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            893,
+            663,
+            928
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that this is a particular case of Gabor filters with center frequency equal to 0 and learnable bandwidth. With this choice, we can learn per-channel lowpass pooling functions while adding only $N$ parameters to the frontend model. We initialize all channels with a bandwidth of 0.4, which gives a frequency response close to the Hann window used by mel-filterbanks. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 LEARNING PER-CHANNEL COMPRESSION AND NORMALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            178,
+            655,
+            190
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "When using a traditional frontend based on a mel-filterbank or STFT, the time-frequency features are typically passed through a logarithmic compression, to replicate the non-linear human perception of loudness (Fechner et al., 1966). The first limitation of this approach is that the same compression function is applied to all frequency bins, regardless of their content. The second limitation is the fixed choice of the non-linearity used by the compression function. While, in most cases, a logarithmic function is used, other compression functions have been proposed and evaluated in the past, including the cubic root (Lyons & Paliwal, 2008) and the 10th root (Schluter et al., 2007). This motivates learning the compression function as part of the model, rather than relying on a handcrafted choice. In particular, Per-Channel Energy Normalization (Wang et al., 2017) was proposed as a learnable alternative to log-compression and mean-variance normalization: ",
+        "bbox": [
+            173,
+            202,
+            825,
+            342
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b901e8e24bfc7d652c90abd5293f94a15787c398c550e315c8ecba71213eab38.jpg",
+        "text": "$$\n\\mathrm { P C E N } ( \\mathcal { F } ( t , n ) ) = \\left( \\frac { \\mathcal { F } ( t , n ) } { { \\left( \\varepsilon + \\mathcal { M } ( t , n ) \\right) } ^ { \\alpha _ { n } } } + \\delta _ { n } \\right) ^ { r _ { n } } - \\delta _ { n } ^ { r _ { n } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            348,
+            686,
+            383
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $t = 1 , \\ldots , M$ denotes the time-step and $n = 1 , \\ldots , N$ the channel index. In this parametrization, the time-frequency representation $\\mathcal { F }$ is first normalized by an exponential moving average of its past values $\\mathcal { M } ( t , n ) = ( 1 - s ) \\mathcal { M } ( t - 1 , n ) + s \\mathcal { F } ( t , n )$ , controlled by a smoothing coefficient $s$ and an exponent $\\alpha _ { n }$ , with $\\varepsilon$ being a small constant used to avoid dividing by zero. An offset $\\delta _ { n }$ is then added before applying compression with the exponent $r _ { n }$ (typically in $[ 0 , 1 ] \\cdot$ ). Wang et al. (2017) train $\\alpha _ { n }$ , $\\delta _ { n }$ , and $r _ { n }$ , while treating $s$ as a hyperparameter, or learning a convex combination of exponential moving averages for different, fixed values of $s$ . Instead, in this work we learn channel-dependent smoothing coefficients $s _ { n }$ , jointly with the rest of the parameters. We call this version sPCEN. This approach was previously used by Schluter & Lehner ¨ (2018) for singing voice detection, except that they did not learn the exponents $\\alpha _ { n }$ , while we learn all these parameters jointly. Our final frontend cascades a Gabor 1D-convolution, a Gaussian lowpass pooling, and sPCEN. In the rest of the paper, we refer to this model as LEAF, for “LEarnable Audio Frontend”. ",
+        "bbox": [
+            174,
+            388,
+            825,
+            555
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            575,
+            326,
+            592
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our frontend on three supervised learning problems: i) single-task classification; ii) multi-task classification and iii) multi-label classification on Audioset. As baselines, we compare our system to log-compressed mel-filterbanks, learnable Time-Domain filterbanks (Zeghidour et al., 2018a)2 and SincNet (Ravanelli & Bengio, 2018)3. In all our experiments, we keep the same common backbone network architecture, which consists of a frontend, a convolutional encoder, and one (or more) head(s). We adopt the lightweight version of EfficientNet (Tan & Le, 2019) (EfficientNetB0, with $4 \\mathrm { M }$ parameters) as convolutional encoder. On AudioSet, we also experiment with a state-of-the-art CNN14 encoder (Kong et al., 2019), with $8 1 \\mathrm { M }$ parameters. A head is a single linear layer with a number of outputs equal to the number of classes. In the multi-task setting we use a different head for each of the target tasks, all sharing the same encoder. ",
+        "bbox": [
+            174,
+            607,
+            825,
+            746
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The input signal sampled at $F _ { s } = 1 6 \\mathrm { k H z }$ is passed through the frontend which feeds into the convolutional encoder. As baseline, we use a log-compressed mel-filterbank with 40 channels, computed over windows of $2 5 \\mathrm { m s }$ with a stride of $1 0 \\mathrm { m s }$ . For a fair comparison, both LEAF and the learnable baselines also have $N = 4 0$ filters, each with $W = 4 0 1$ coefficients ${ \\approx } 2 5 \\mathrm { m s }$ at $1 6 \\mathrm { k H z }$ ). The learnable pooling is computed over 401 samples with a stride of 160 samples $\\mathrm { 1 0 m s }$ at $1 6 \\mathrm { k H z }$ ), giving the same output dimension as mel-filterbanks. On AudioSet we use 64 channels instead of 40 as Kong et al. (2019) observed improvements from using 64 mel-filters. ",
+        "bbox": [
+            174,
+            752,
+            825,
+            851
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To address the variable length of the input sequences, we train on randomly sampled 1 second windows. We train with ADAM (Kingma & Ba, 2014) and a learning rate of $1 \\dot { 0 } ^ { - 4 }$ for $1 \\mathrm { M }$ batches, with batch size 256. For Audioset experiments, we train with mixup (Zhang et al., 2017) and SpecAugment (Park et al., 2019). During evaluation, we consider the full-length sequences, splitting them into consecutive non-overlapping 1 second windows and averaging the output logits over windows. ",
+        "bbox": [
+            176,
+            858,
+            821,
+            886
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/43f482ee1041495d9d2e13998411ef15c87a6a6f2f61fe0d14e70ed9c373400f.jpg",
+        "table_caption": [
+            "Table 1: Test accuracy $( \\% )$ for single-task classification. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Task</td><td>Mel</td><td>TD-fbanks</td><td>SincNet</td><td>LEAF</td></tr><tr><td>Acoustic scenes</td><td>99.2 ± 0.4</td><td>99.5 ± 0.3</td><td>96.7 ± 0.9</td><td>99.1 ± 0.5</td></tr><tr><td>Birdsong detection</td><td>78.6 ±1.0</td><td>80.9 ±0.9</td><td>78.0 ±1.0</td><td>81.4±0.9</td></tr><tr><td>Emotion recognition</td><td>49.1 ± 2.4</td><td>57.1 ± 2.4</td><td>44.2 ± 2.4</td><td>57.8±2.4</td></tr><tr><td>Speaker Id. (VC)</td><td>31.9 ± 0.7</td><td>25.3 ± 0.7</td><td>43.5 ± 0.8</td><td>33.1 ± 0.7</td></tr><tr><td>Music (instrument)</td><td>72.0± 0.6</td><td>70.0 ± 0.6</td><td>70.3± 0.6</td><td>72.0± 0.6</td></tr><tr><td>Music (pitch)</td><td>91.5 ± 0.3</td><td>91.3 ± 0.3</td><td>83.8 ± 0.5</td><td>92.0 ± 0.3</td></tr><tr><td>Speech commands</td><td>92.4±0.4</td><td>87.3 ± 0.4</td><td>89.2± 0.4</td><td>93.4±0.3</td></tr><tr><td>Language Id.</td><td>76.5 ± 0.4</td><td>71.6 ± 0.5</td><td>78.9 ± 0.4</td><td>86.0±0.4</td></tr><tr><td>Average</td><td>73.9 ±0.8</td><td>72.9 ± 0.8</td><td>73.1 ± 0.9</td><td>76.9 ± 0.8</td></tr></table>",
+        "bbox": [
+            250,
+            127,
+            745,
+            273
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/aea00a4cf2e2d8e8504fbe4cc571ebb4281067501fb140958a843a8b6093d3ef.jpg",
+        "table_caption": [
+            "Table 2: Impact of the compression layer on the performance (single task, average accuracy in $\\%$ ). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"3\">mel-filterbank</td><td colspan=\"3\">LEAF- filterbank</td></tr><tr><td>log</td><td>PCEN</td><td>sPCEN</td><td>log</td><td>PCEN</td><td>sPCEN</td></tr><tr><td>Average</td><td>73.9 ± 0.8</td><td>76.4 ± 0.8</td><td>76.0 ± 0.7</td><td>74.6±0.7</td><td>76.4± 0.8</td><td>76.9 ± 0.8</td></tr></table>",
+        "bbox": [
+            207,
+            306,
+            785,
+            366
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            383,
+            823,
+            425
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 SINGLE-TASK AUDIO CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            443,
+            477,
+            457
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We train independent single-task supervised models on 8 distinct classification problems: acoustic scene classification on TUT (Heittola et al., 2018), birdsong detection (Stowell et al., 2018), emotion recognition on Crema-D (Cao et al., 2014), speaker identification on VoxCeleb (Nagrani et al., 2017), musical instrument and pitch detection on NSynth (Engel et al., 2017), keyword spotting on Speech Commands (Warden, 2018), and language identification on VoxForge (Revay & Teschke, 2019). A summary of the datasets used in our experiments is illustrated in Table A.1. ",
+        "bbox": [
+            174,
+            468,
+            825,
+            551
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1 reports the results for each task, with $9 5 \\%$ confidence intervals representing the uncertainty due to the limited test sample size. No class rebalancing is applied, neither during training, nor during testing. On average, we observe that LEAF outperforms all alternatives. When considering results for each individual tasks, we observe that LEAF outperforms or matches the accuracy of other frontends, with the notable exception of SincNet on Voxceleb. This is consistent with the fact that SincNet was originally proposed for speaker identification (Ravanelli & Bengio, 2018) and illustrates the importance of evaluating over a wide range of tasks. To evaluate the robustness of our results with respect to the choice of the datasets, we apply a statistical bootstrap (Efron & Tibshirani, 1993) to compute the non-parametric distribution of the difference between the accuracy obtained with LEAF and each of the other frontends, when sampling datasets with replacement among the eight datasets. We test the null hypothesis that the mean of the difference is zero and measure the following one-sided $\\mathsf { p }$ -values: $\\dot { p _ { \\mathrm { M e l } } } ~ < ~ 1 0 ^ { - 5 }$ , $ { p _ { \\mathrm { T D - f b a n k s } } } ~ < ~ 1 0 ^ { - 5 }$ , $p _ { \\mathrm { S i n c N e t } } ~ = ~ 0 . 0 5 9$ . Figure A.1 illustrates the corresponding bootstrap distribution, showing the statistical significance of our results with respect to the choice of the datasets. In Table 2, we study the effect of the compression function. PCEN improves significantly over log-compression on both mel- and learned filterbanks. We also observe that for any choice of the compression function, the learnable frontend matches or outperforms the corresponding mel-filterbank. ",
+        "bbox": [
+            174,
+            559,
+            825,
+            795
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 MULTI-TASK AUDIO CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            813,
+            472,
+            825
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To learn a general-purpose frontend that generalizes across tasks, we train a multi-task model that uses the same LEAF parameters and encoder for all tasks, with a task-specific linear head. More specifically, a single network with $K$ heads $( h _ { \\theta _ { 1 } } , \\ldots , h _ { \\theta _ { K } } )$ is trained on mini-batches, uniformly sampled from the $K$ datasets. A mini-batch of size $B$ can be represented as $( x _ { i } ^ { k _ { i } } , y _ { i } ^ { k _ { i } } ) _ { i = 1 \\dots B }$ , where $k _ { i }$ is the associated task the example has been sampled from. The multi-task loss function is now computed on a mini-batch as the sum of the individual loss functions: ",
+        "bbox": [
+            174,
+            838,
+            823,
+            922
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/ed9d8a3208a40ff6a0003f29416bfe56972a1c7a24cc865b130ba6c46e11a669.jpg",
+        "table_caption": [
+            "Table 3: Test accuracy $( \\% )$ for multi-task classification. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Task</td><td>Mel</td><td>TD-fbanks</td><td>SincNet</td><td>LEAF</td></tr><tr><td>Acoustic scenes</td><td>99.1 ± 0.5</td><td>98.3±0.6</td><td>91.0 ± 1.4</td><td>98.9 ± 0.5</td></tr><tr><td>Birdsong detection</td><td>81.3± 0.9</td><td>82.3±0.9</td><td>78.8±0.9</td><td>81.9 ±0.9</td></tr><tr><td>Emotion recognition</td><td>24.1 ± 2.1</td><td>24.4±2.1</td><td>26.2 ± 2.1</td><td>31.9 ± 2.3</td></tr><tr><td>Speaker Id. (LBS)</td><td>100.0 ± 0.0</td><td>100.0± 0.0</td><td>100.0 ± 0.0</td><td>100.0 ± 0.0</td></tr><tr><td>Music (instrument)</td><td>70.7 ± 0.6</td><td>66.3± 0.6</td><td>67.4± 0.6</td><td>70.2 ±0.6</td></tr><tr><td>Music (pitch)</td><td>88.5 ± 0.4</td><td>86.4 ± 0.4</td><td>81.2 ± 0.5</td><td>88.6 ± 0.4</td></tr><tr><td>Speech commands</td><td>93.6 ± 0.3</td><td>89.5 ± 0.4</td><td>91.4 ± 0.4</td><td>93.6 ±0.3</td></tr><tr><td>Language Id.</td><td>64.9 ±0.5</td><td>58.9 ± 0.5</td><td>60.8 ± 0.5</td><td>69.6 ± 0.5</td></tr><tr><td>Average</td><td>77.8±0.7</td><td>75.8 ±0.7</td><td>74.6± 0.8</td><td>79.3 ± 0.7</td></tr></table>",
+        "bbox": [
+            235,
+            127,
+            763,
+            275
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/f19eb48ef28e84c9315a799fe8124462e2d8cc4378700ede6448562d57f1d86e.jpg",
+        "table_caption": [
+            "Table 4: Test AUC and d-prime ( $\\pm$ standard deviation over three runs) on Audioset, with the number of learnable parameters per frontend. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td colspan=\"2\">EfficientNetB0</td><td colspan=\"2\">CNN14 (ours)</td><td colspan=\"2\">CNN14 (Kong et al., 2019)</td></tr><tr><td>Frontend</td><td>#Params</td><td>AUC</td><td>d-prime</td><td>AUC</td><td>d-prime</td><td>AUC</td><td>d-prime</td></tr><tr><td>Mel</td><td>0</td><td>0.968 ± .001</td><td>2.61± .02</td><td>0.972 ± .000</td><td>2.71± .01</td><td>0.973</td><td>2.73</td></tr><tr><td>Mel-PCEN</td><td>256</td><td>0.967 ± .000</td><td>2.60± .01</td><td>0.973± .000</td><td>2.72 ± .00</td><td>-</td><td>-</td></tr><tr><td>Wavegram</td><td>300k</td><td>0.958 ± .000</td><td>2.44± .00</td><td>0.961 ± .001</td><td>2.50± .02</td><td>0.968</td><td>2.61</td></tr><tr><td>TD-fbanks</td><td>51k</td><td>0.965 ± .001</td><td>2.57± .01</td><td>0.972 ± .000</td><td>2.70±.00</td><td>-</td><td>-</td></tr><tr><td>SincNet</td><td>256</td><td>0.961 ± .000</td><td>2.48±.00</td><td>0.970 ± .000</td><td>2.66 ± .01</td><td>=</td><td>-</td></tr><tr><td>SincNet+</td><td>448</td><td>0.966 ± .002</td><td>2.58± .04</td><td>0.973± .001</td><td>2.71± .01</td><td></td><td>=</td></tr><tr><td>LEAF</td><td>448</td><td>0.968 ± .001</td><td>2.63± .01</td><td>0.974± .000</td><td>2.74± .01</td><td></td><td></td></tr></table>",
+        "bbox": [
+            174,
+            327,
+            825,
+            463
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5045197e3d12df5eb183a0ea64565cbd68a253f06403171b6b4359d3cab0742c.jpg",
+        "text": "$$\n\\mathcal { L } = \\sum _ { i = 1 } ^ { B } \\sum _ { k = 1 } ^ { K } \\mathcal { L } _ { k } \\left( h _ { \\theta _ { k } } \\left( g _ { \\theta } ( \\mathcal { F } _ { \\psi } ( x _ { i } ^ { k _ { i } } ) \\right) , y _ { i } ^ { k _ { i } } \\right) \\delta ( k _ { i } , k ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            492,
+            671,
+            536
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $\\theta$ and $\\psi$ represent the shared parameters of the encoder and frontend respectively, $\\theta _ { k }$ , $k =$ $1 , \\ldots , K$ the task-specific parameters of the heads $h _ { \\theta _ { k } } ( \\cdot )$ , and $\\delta$ is the Kronecker delta function. ",
+        "bbox": [
+            171,
+            539,
+            821,
+            568
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We use the same set of tasks described in Section 4.1 with one exception, replacing VoxCeleb with Librispeech for speaker identification. As illustrated in Table A.1, VoxCeleb has much more classes $( \\approx 1 2 0 0 )$ than any other task. This creates an imbalance in the number of parameters in the heads, making training significantly slower and reducing the accuracy on all other tasks, regardless of the frontend. Table 3 reports the accuracy obtained on each task, for all the frontends. LEAF shows the best overall performance while matching or outperforming all other methods on every tasks. We repeated the bootstrap analysis (Figure A.2) to evaluate the statistical significance of these results with respect to the choice of the datasets and observed the following p-values: $p _ { \\mathrm { M e l } } = 0 . 0 4 8$ , $p _ { \\mathrm { T D } } .$ -fbanks $< 1 0 ^ { - 5 }$ , $p _ { \\mathrm { S i n c N e t } } = 1 0 ^ { - 5 }$ . To the best of our knowledge, it is the first time a learnable frontend is shown to outperform mel-filterbanks over several tasks with a unique parametrization. ",
+        "bbox": [
+            174,
+            573,
+            825,
+            713
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 MULTI-LABEL CLASSIFICATION ON AUDIOSET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            731,
+            537,
+            744
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 4 shows the performance (averaged over three runs) of the different frontends on Audioset (Gemmeke et al., 2017), a large-scale multi-label dataset of sounds of all categories, described by an ontology of 527 classes. Audioset examples are weakly labelled with one or more positive labels, so we evaluate with the standard metric of this dataset, the balanced d-prime, a non-linear transformation of the AUC averaged uniformly across all classes. EfficientNetB0 trained with LEAF achieves a d-prime of 2.63, outperforming the level achieved when using mel-filterbanks (d-prime: 2.61) or other frontends. We compare this result with the state-of-the-art PANN model (Kong et al., 2019), which reports a d-prime of 2.73 when trained on mel-filterbanks. Kong et al. (2019) also train a learnable “Wavegram” frontend made of 9 layers of 1D- and 2D- convolutions, for a total of $3 0 0 \\mathrm { k }$ parameters, reporting a d-prime equal to 2.61. EfficientNetB0 on LEAF thus outperforms this system, while having a frontend with 670x fewer parameters, and a considerably smaller encoder. To confirm these results, we also train EfficientNetB0 on the Wavegram and get similar findings. ",
+        "bbox": [
+            173,
+            757,
+            825,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "All these findings are replicated when replacing EfficientNetB0 with our implementation of CNN14: even though the gap between LEAF and baselines reduces as the scores get higher, CNN14 on LEAF matches the current state-of-the-art on AudioSet. To conclude these experiments and show that individual components of LEAF can benefit other frontends, we replace the max-pooling of SincNet with our Gaussian lowpass filter, and LayerNorm (Ba et al., 2016) with the proposed sPCEN. This version, named “SincNet+” in Table 4, significantly outperforms the original version. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4 ANALYSIS OF LEARNED FILTERS, POOLING AND COMPRESSION ",
+        "bbox": [
+            174,
+            205,
+            648,
+            219
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure A.3 illustrates the center frequencies learned by the Gabor filtering layer of LEAF on AudioSet, and compares them to those of mel-filterbanks. At a high level, these filters do not deviate much from their mel-scale initialization. On the one hand, this indicates that the mel-scale is a strong initialization, a result consistent with previous work (Sainath et al., 2015; Zeghidour et al., 2018b). On the other hand, there are differences at both ends of the range, with LEAF covering a wider range of frequencies. For example, the lowest frequency filter is centered around $6 0 \\mathrm { H z }$ , as opposed to $1 0 0 \\mathrm { H z }$ for mel-filterbanks. We believe that is one of the reasons that explain the out-performance of LEAF on Audioset, as it focuses on a more appropriate frequency range to represent the underlying audio events. Figure A.4 shows the learned Gaussian lowpass filters at convergence. We see that they all deviate towards a larger frequency bandwidth (characterized by a smaller standard deviation in the time domain), and that each filter has a different bandwidth, which confirms the utility of using depthwise pooling. Figure A.5 shows the learned exponents $r _ { n }$ (initialized at 2.0) and smoothing coefficients $s _ { n }$ (initialized at 0.04) of sPCEN, ordered by filter index. The exponents are spread in [1.9, 2.6], which shows the importance of learning per-channel exponents, as well as the appropriate choice of using a fixed cubic root in previous work (Lyons & Paliwal, 2008), as an alternative to log-compression. Learning per-channel smoothing coefficients also allows deviating from the initialization. Interestingly, most filters keep a low coefficient (slowly moving average), except for the filter with the highest frequency, which has a significantly faster moving average $( s { \\approx } 0 . 1 5 )$ . ",
+        "bbox": [
+            174,
+            232,
+            825,
+            481
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.5 ROBUSTNESS TO NOISE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            500,
+            377,
+            512
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We compare the robustness of LEAF and mel-filterbanks to synthetic noise, on the Speech Commands dataset. To do so, we artificially add Gaussian noise to the waveforms both during training and evaluation, with different gains to obtain a Signal-to-Noise Ratio (SNR) from $+ \\mathrm { i n f }$ (no noise) to $- 5 \\mathrm { d B }$ . Figure A.6 shows that while performance (averaged over three runs) degrades for all models as SNR decreases, LEAF is more resilient than mel-filterbanks. In particular, when using a logarithmic compression, the Gabor 1-D convolution and Gaussian pooling of LEAF maintain a significantly higher accuracy than mel-filterbanks. Using PCEN has an even higher impact on performance when using mel-filterbanks, the best results being obtained with LEAF $^ +$ PCEN. ",
+        "bbox": [
+            174,
+            525,
+            825,
+            636
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            657,
+            318,
+            672
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work we introduce LEAF, a fully learnable frontend for audio classification as an alternative to using handcrafted mel-filterbanks. We demonstrate over a large range of tasks that our model is a good drop-in replacement to these features with no adjustment to the task at hand, and can even learn a single set of parameters for general-purpose audio classification while outperforming previously proposed learnable frontends. In future work, we will move yet a step forward in removing handcrafted biases from the model. In particular, our model still relies on an underlying convolutional architecture, with fixed filter length and stride. Learning these important parameters directly from data would allow for an easier generalization across tasks with various sampling rates and frequency content. Moreover, we believe that the general principle of learning to filter, pool and compress can benefit the analysis of non-audio signals, such as seismic data or physiological recordings. ",
+        "bbox": [
+            174,
+            689,
+            825,
+            829
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            849,
+            387,
+            866
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Authors thank Dick Lyon, Vincent Lostanlen, Matt Harvey, and Alex Park for helpful discussions. Authors are also thankful to Julie Thomas for helping with the design of Figure 1. Finally, authors thank the reviewers of ICLR 2021 for their feedback that helped improving the quality of this work. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Joakim Anden and St ´ ephane Mallat. Deep scattering spectrum. ´ IEEE Transactions on Signal Processing, 62(16):4114–4128, 2014. ",
+        "bbox": [
+            173,
+            127,
+            823,
+            155
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Blaise Aguera y Arcas, Beat Gfeller, Ruiqi Guo, Kevin Kilgour, Sanjiv Kumar, James Lyon, Julian ¨ Odell, Marvin Ritter, Dominik Roblek, Matthew Sharifi, and Mihajlo Velimirovic. Now Playing: ´ Continuous low-power music recognition. Technical report, nov 2017. URL http://arxiv. org/abs/1711.10958. ",
+        "bbox": [
+            173,
+            167,
+            825,
+            223
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016. ",
+        "bbox": [
+            171,
+            236,
+            823,
+            266
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Randall Balestriero, Romain Cosentino, Herve Glotin, and Richard Baraniuk. Spline filters for ´ end-to-end deep learning. In International Conference on Machine Learning, pp. 364–373, 2018. ",
+        "bbox": [
+            171,
+            277,
+            823,
+            308
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Eric Battenberg, Rewon Child, Adam Coates, Christopher Fougner, Yashesh Gaur, Jiaji Huang, Heewoo Jun, Ajay Kannan, Markus Kliegl, Atul Kumar, et al. Reducing bias in production speech models. arXiv preprint arXiv:1705.04400, 2017. ",
+        "bbox": [
+            173,
+            318,
+            823,
+            362
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Houwei Cao, David G Cooper, Michael K Keutmann, Ruben C Gur, Ani Nenkova, and Ragini Verma. CREMA-D: Crowd-sourced emotional multimodal actors dataset. IEEE transactions on affective computing, 5(4):377–390, 2014. ",
+        "bbox": [
+            173,
+            373,
+            826,
+            416
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Steven Davis and Paul Mermelstein. Comparison of parametric representations for monosyllabic word recognition in continuously spoken sentences. IEEE transactions on acoustics, speech, and signal processing, 28(4):357–366, 1980. ",
+        "bbox": [
+            174,
+            429,
+            823,
+            470
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bradley Efron and Robert J. Tibshirani. An Introduction to the Bootstrap. Number 57 in Monographs on Statistics and Applied Probability. Chapman & Hall/CRC, Boca Raton, Florida, USA, 1993. ",
+        "bbox": [
+            171,
+            483,
+            823,
+            513
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jesse Engel, Cinjon Resnick, Adam Roberts, Sander Dieleman, Douglas Eck, Karen Simonyan, and Mohammad Norouzi. Neural Audio Synthesis of Musical Notes with WaveNet Autoencoders. Technical report, apr 2017. URL http://arxiv.org/abs/1704.01279. ",
+        "bbox": [
+            173,
+            523,
+            825,
+            568
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tiago H Falk and Wai-Yip Chan. Modulation spectral features for robust far-field speaker identification. IEEE Transactions on Audio, Speech, and Language Processing, 18(1):90–100, 2009. ",
+        "bbox": [
+            171,
+            579,
+            823,
+            608
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gustav Theodor Fechner, Davis H Howes, and Edwin Garrigues Boring. Elements of psychophysics, volume 1. Holt, Rinehart and Winston New York, 1966. ",
+        "bbox": [
+            173,
+            619,
+            821,
+            648
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dennis Gabor. Theory of communication. part 1: The analysis of information. Journal of the Institution of Electrical Engineers-Part III: Radio and Communication Engineering, 93(26):429– 441, 1946. ",
+        "bbox": [
+            173,
+            661,
+            825,
+            704
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jort F Gemmeke, Daniel PW Ellis, Dylan Freedman, Aren Jansen, Wade Lawrence, R Channing Moore, Manoj Plakal, and Marvin Ritter. Audio set: An ontology and human-labeled dataset for audio events. In 2017 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 776–780. IEEE, 2017. ",
+        "bbox": [
+            173,
+            715,
+            825,
+            773
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Donald D. Greenwood. The mel scale’s disqualifying bias and a consistency of pitch-difference equisections in 1956 with equal cochlear distances and equal frequency ratios. Hearing Research, 103:199–224, 1997. ",
+        "bbox": [
+            173,
+            785,
+            825,
+            828
+        ],
+        "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": [
+            171,
+            840,
+            823,
+            882
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Toni Heittola, Annamaria Mesaros, and Tuomas Virtanen. TUT Urban Acoustic Scenes 2018, Development dataset, April 2018. URL https://doi.org/10.5281/zenodo.1228142. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shawn Hershey, Sourish Chaudhuri, Daniel P.W. Ellis, Jort F Gemmeke, Aren Jansen, R Channing Moore, Manoj Plakal, Devin Platt, Rif A Saurous, Bryan Seybold, Malcolm Slaney, Ron J Weiss, and Kevin Wilson. CNN architectures for large-scale audio classification. In ICASSP, IEEE International Conference on Acoustics, Speech and Signal Processing - Proceedings, pp. 131– 135, 2017. ISBN 9781509041176. doi: 10.1109/ICASSP.2017.7952132. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton, Li Deng, Dong Yu, George E Dahl, Abdel-rahman Mohamed, Navdeep Jaitly, Andrew Senior, Vincent Vanhoucke, Patrick Nguyen, Tara N Sainath, et al. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal processing magazine, 29(6):82–97, 2012. ",
+        "bbox": [
+            174,
+            183,
+            825,
+            239
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yedid Hoshen, Ron Weiss, and Kevin W Wilson. Speech acoustic modeling from raw multichannel waveforms. In International Conference on Acoustics, Speech, and Signal Processing, 2015. ",
+        "bbox": [
+            174,
+            248,
+            823,
+            277
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 4700–4708, 2017. ",
+        "bbox": [
+            173,
+            286,
+            825,
+            329
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Navdeep Jaitly and Geoffrey Hinton. Learning a better representation of speech soundwaves using restricted boltzmann machines. In 2011 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 5884–5887. IEEE, 2011. ",
+        "bbox": [
+            173,
+            338,
+            823,
+            381
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            171,
+            390,
+            823,
+            419
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Qiuqiang Kong, Yin Cao, T. Iqbal, Yuxuan Wang, Wenwu Wang, and Mark D. Plumbley. Panns: Large-scale pretrained audio neural networks for audio pattern recognition. ArXiv, abs/1912.10211, 2019. ",
+        "bbox": [
+            174,
+            428,
+            823,
+            470
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012. ",
+        "bbox": [
+            174,
+            479,
+            823,
+            522
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "V. Lostanlen, J. Salamon, M. Cartwright, B. McFee, A. Farnsworth, S. Kelling, and J. P. Bello. Per-channel energy normalization: Why and how. IEEE Signal Processing Letters, 26(1):39–43, 2019. ",
+        "bbox": [
+            174,
+            531,
+            825,
+            574
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Vincent Lostanlen, Justin Salamon, Andrew Farnsworth, Steve Kelling, and Juan Pablo Bello. Birdvox-full-night: A dataset and benchmark for avian flight call detection. In 2018 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 266–270. IEEE, 2018. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            640
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yi Luo and Nima Mesgarani. Conv-tasnet: Surpassing ideal time-frequency magnitude masking for speech separation. IEEE/ACM Trans. Audio, Speech & Language Processing, 27(8):1256–1266, 2019. ",
+        "bbox": [
+            174,
+            650,
+            825,
+            691
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yi Luo, Zhuo Chen, and Takuya Yoshioka. Dual-path rnn: efficient long sequence modeling for time-domain single-channel speech separation. arXiv preprint arXiv:1910.06379, 2019. ",
+        "bbox": [
+            171,
+            702,
+            823,
+            731
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "James G Lyons and Kuldip K Paliwal. Effect of compressing the dynamic range of the power spectrum in modulation filtering based speech enhancement. In Ninth Annual Conference of the International Speech Communication Association, 2008. ",
+        "bbox": [
+            173,
+            739,
+            825,
+            782
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nelson Mogran, Herve Bourlard, and Hynek Hermansky. Automatic speech recognition: An audi- ´ tory perspective. In Speech processing in the auditory system, pp. 309–338. Springer, 2004. ",
+        "bbox": [
+            169,
+            791,
+            823,
+            820
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Arsha Nagrani, Joon Son Chung, and Andrew Zisserman. Voxceleb: A large-scale speaker identification dataset. Interspeech 2017, Aug 2017. doi: 10.21437/interspeech.2017-950. URL http://dx.doi.org/10.21437/Interspeech.2017-950. ",
+        "bbox": [
+            174,
+            829,
+            823,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Paul-Gauthier Noe, Titouan Parcollet, and Mohamed Morchid. Cgcnn: Complex gabor convolu- ´ tional neural network on raw speech. ICASSP 2020 - 2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 7724–7728, 2020. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "D. O’Shaughnessy. Speech communication $:$ human and machine. 1987. ",
+        "bbox": [
+            173,
+            103,
+            650,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Dimitri Palaz, Ronan Collobert, and Mathew Magimai Doss. Estimating phoneme class conditional probabilities from raw speech signal using convolutional neural networks. arXiv preprint arXiv:1304.1018, 2013. ",
+        "bbox": [
+            174,
+            127,
+            823,
+            170
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Dimitri Palaz, Mathew Magimai Doss, and Ronan Collobert. Convolutional neural networks-based continuous speech recognition using raw speech signal. In 2015 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 4295–4299. IEEE, 2015. ",
+        "bbox": [
+            174,
+            179,
+            823,
+            223
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Manuel Pariente, Samuele Cornell, Antoine Deleforge, and Emmanuel Vincent. Filterbank design for end-to-end speech separation. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 6364–6368. IEEE, 2020. ",
+        "bbox": [
+            174,
+            231,
+            823,
+            275
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Daniel S Park, William Chan, Yu Zhang, Chung-Cheng Chiu, Barret Zoph, Ekin D Cubuk, and Quoc V Le. Specaugment: A simple data augmentation method for automatic speech recognition. arXiv preprint arXiv:1904.08779, 2019. ",
+        "bbox": [
+            176,
+            284,
+            825,
+            327
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mirco Ravanelli and Yoshua Bengio. Speaker recognition from raw waveform with sincnet. In 2018 IEEE Spoken Language Technology Workshop (SLT), pp. 1021–1028. IEEE, 2018. ",
+        "bbox": [
+            171,
+            335,
+            823,
+            366
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shauna Revay and Matthew Teschke. Multiclass language identification using deep learning on spectral images of audio signals. CoRR, abs/1905.04348, 2019. URL http://arxiv.org/ abs/1905.04348. ",
+        "bbox": [
+            173,
+            375,
+            823,
+            416
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "T. Sainath, Brian Kingsbury, Abdel rahman Mohamed, and B. Ramabhadran. Learning filter banks within a deep neural network framework. 2013 IEEE Workshop on Automatic Speech Recognition and Understanding, pp. 297–302, 2013. ",
+        "bbox": [
+            176,
+            426,
+            823,
+            469
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tara N Sainath, Ron J Weiss, Andrew Senior, Kevin W Wilson, and Oriol Vinyals. Learning the speech front-end with raw waveform cldnns. In Sixteenth Annual Conference of the International Speech Communication Association, 2015. ",
+        "bbox": [
+            174,
+            478,
+            823,
+            521
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jan Schluter and Bernhard Lehner. Zero-mean convolutions for level-invariant singing voice detec- ¨ tion. In ISMIR, 2018. ",
+        "bbox": [
+            169,
+            530,
+            823,
+            559
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ralf Schluter, Ilja Bezrukov, Hermann Wagner, and Hermann Ney. Gammatone features and feature combination for large vocabulary speech recognition. In 2007 IEEE International Conference on Acoustics, Speech and Signal Processing-ICASSP’07, volume 4, pp. IV–649. IEEE, 2007. ",
+        "bbox": [
+            174,
+            568,
+            823,
+            612
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Steffen Schneider, Alexei Baevski, Ronan Collobert, and Michael Auli. wav2vec: Unsupervised pre-training for speech recognition. arXiv preprint arXiv:1904.05862, 2019. ",
+        "bbox": [
+            173,
+            621,
+            823,
+            650
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Andrew Senior, Hasim Sak, Felix de Chaumont Quitry, Tara N. Sainath, and Kanishka Rao. Acoustic modelling with cd-ctc-smbr lstm rnns. In ASRU, 2015. ",
+        "bbox": [
+            171,
+            659,
+            821,
+            688
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Stanley S Stevens and John Volkmann. The relation of pitch to frequency: A revised scale. The American Journal of Psychology, 53(3):329–353, 1940. ",
+        "bbox": [
+            171,
+            696,
+            823,
+            727
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Dan Stowell, — Mike Wood, — Hanna Pamuła, Yannis Stylianou, and Herve Glotin. Automatic ´ acoustic detection of birds through deep learning: the first Bird Audio Detection challenge. Technical report, 2018. URL https://arxiv.org/pdf/1807.05812.pdf. ",
+        "bbox": [
+            173,
+            736,
+            821,
+            779
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Gabriel Synnaeve, Qiantong Xu, Jacob Kahn, Edouard Grave, Tatiana Likhomanenko, Vineel Pratap, Anuroop Sriram, Vitaliy Liptchinsky, and Ronan Collobert. End-to-end asr: from supervised to semi-supervised learning with modern architectures. arXiv preprint arXiv:1911.08460, 2019. ",
+        "bbox": [
+            174,
+            787,
+            825,
+            843
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mingxing Tan and Quoc V. Le. Efficientnet: Rethinking model scaling for convolutional neural networks. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, volume 97 of Proceedings of Machine Learning Research, pp. 6105–6114. PMLR, 2019. URL http://proceedings.mlr.press/v97/tan19a.html. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Samuel Thomas, Sriram Ganapathy, and Hynek Hermansky. Hilbert envelope based features for far-field speech recognition. In International Workshop on Machine Learning for Multimodal Interaction, pp. 119–124. Springer, 2008. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Andros Tjandra, Sakriani Sakti, and Satoshi Nakamura. Attention-based wav2text with feature transfer learning. In 2017 IEEE automatic speech recognition and understanding workshop (ASRU), pp. 309–315. IEEE, 2017. ",
+        "bbox": [
+            174,
+            155,
+            821,
+            196
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "S. Umesh, L. Cohen, and D. Nelson. Fitting the mel scale. 1999 IEEE International Conference on Acoustics, Speech, and Signal Processing. Proceedings. ICASSP99 (Cat. No.99CH36258), 1: 217–220 vol.1, 1999. ",
+        "bbox": [
+            176,
+            205,
+            823,
+            250
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jesus Villalba, Nanxin Chen, David Snyder, Daniel Garcia-Romero, Alan McCree, Gregory Sell, ´ Jonas Borgstrom, Leibny Paola Garc´ıa-Perera, Fred Richardson, Reda Dehak, et al. State-of-the-´ art speaker recognition with neural network embeddings in nist sre18 and speakers in the wild evaluations. Computer Speech & Language, 60:101026, 2020. ",
+        "bbox": [
+            171,
+            257,
+            826,
+            314
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yuxuan Wang, Pascal Getreuer, Thad Hughes, Richard F Lyon, and Rif A Saurous. Trainable frontend for robust and far-field keyword spotting. In 2017 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 5670–5674. IEEE, 2017. ",
+        "bbox": [
+            173,
+            323,
+            821,
+            367
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Pete Warden. Speech Commands: A Dataset for Limited-Vocabulary Speech Recognition. Technical report, 2018. URL https://arxiv.org/pdf/1804.03209.pdf. ",
+        "bbox": [
+            171,
+            375,
+            823,
+            405
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Neil Zeghidour, Nicolas Usunier, Iasonas Kokkinos, Thomas Schatz, Gabriel Synnaeve, and Emmanuel Dupoux. Learning filterbanks from raw speech for phone recognition. In 2018 IEEE international conference on acoustics, speech and signal Processing (ICASSP), pp. 5509–5513. IEEE, 2018a. ",
+        "bbox": [
+            173,
+            412,
+            823,
+            469
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Neil Zeghidour, Nicolas Usunier, Gabriel Synnaeve, Ronan Collobert, and Emmanuel Dupoux. Endto-end speech recognition from the raw waveform. Interspeech, abs/1806.07098, 2018b. ",
+        "bbox": [
+            169,
+            478,
+            821,
+            507
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. arXiv preprint arXiv:1710.09412, 2017. ",
+        "bbox": [
+            169,
+            516,
+            823,
+            545
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Richard Zhang. Making convolutional networks shift-invariant again. arXiv preprint arXiv:1904.11486, 2019. ",
+        "bbox": [
+            173,
+            554,
+            823,
+            583
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            297,
+            117
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/bb16d3c1fe10d88c43b8d976566f5dbd6d07e142837f5b294490637dd32c4060.jpg",
+        "table_caption": [
+            "Table A.1: Datasets used in the experiments. Default train/test splits are always adopted. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Task</td><td>Name</td><td>Classes</td><td>Train examples</td><td>Test examples</td></tr><tr><td>Audio events</td><td>Audioset</td><td>527</td><td>1,832,720</td><td>17,695</td></tr><tr><td>Acoustic scenes</td><td>TUTUrban 2018</td><td>10</td><td>7,829</td><td>810</td></tr><tr><td>Birdsong detection</td><td>DCASE2018</td><td>2</td><td>32,129</td><td>3,561</td></tr><tr><td>Emotion recognition</td><td>Crema-D</td><td>6</td><td>5,146</td><td>820</td></tr><tr><td>Speaker Id.</td><td>Voxceleb</td><td>1,251</td><td>138,361</td><td>8,249</td></tr><tr><td>Speaker Id.</td><td>Librispeech</td><td>251</td><td>25,740</td><td>2,799</td></tr><tr><td>Music (instrument)</td><td>Nsynth</td><td>11</td><td>289,205</td><td>12,678</td></tr><tr><td>Music (pitch)</td><td>Nsynth</td><td>128</td><td>289,205</td><td>12,678</td></tr><tr><td>Speech commands</td><td>Speech commands</td><td>35</td><td>84,771</td><td>10,700</td></tr><tr><td>Language Id.</td><td>Voxforge</td><td>6</td><td>126,610</td><td>18,378</td></tr></table>",
+        "bbox": [
+            223,
+            164,
+            776,
+            316
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/ea4a0adef0aafc6b4d3ab1101a9bf0e45645b0595fec97d9e4f72d1177d8553a.jpg",
+        "image_caption": [
+            "Figure A.1: Distribution of the difference between the accuracy $( \\% )$ obtained with LEAF and each of the other frontends when sampling 8 datasets with replacement, in the single task setting. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            351,
+            821,
+            472
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/c982f096032ab915218b552f395fb370198ea87152f61446ee0cbc3d54f1b9fb.jpg",
+        "image_caption": [
+            "Figure A.2: Distribution of the difference between the accuracy obtained with LEAF and each of the other frontends when sampling 8 datasets with replacement, in the multi-task setting. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            540,
+            823,
+            662
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/96826f630f45395be1f7b24c86d48890d3d93821d4871cadb522f6ecc5a33d0e.jpg",
+        "image_caption": [
+            "Figure A.3: Comparison between the filters learned by LEAF and the mel scale. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            127,
+            813,
+            297
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/a2bc369c176eaa4408f7a1cb1cd59d118888305dbfe79904f3466db07f0015e1.jpg",
+        "image_caption": [
+            "Figure A.4: Learned Gaussian lowpass filters of LEAF on AudioSet. The dotted line represents the initialization, identical for all filters. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            382,
+            753,
+            584
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/6acfe308d30803c48b9553683f6462e63c3c14d2210d26e66074c4b30d5ccb69.jpg",
+        "image_caption": [
+            "Figure A.5: Values of learned sPCEN parameters of LEAF trained on AudioSet. The dotted lines represent the initialization, identical for all filters. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            676,
+            818,
+            853
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/bc4b9e48e7ce47447f4ec2cae15d1c700194a7a5b2126f74d97a4cf6ff063ef4.jpg",
+        "image_caption": [
+            "Figure A.6: Test accuracy $( \\% )$ on the test set of the Speech Commands dataset with varying SNR. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            377,
+            761,
+            643
+        ],
+        "page_idx": 15
+    }
+]

parse/train/rkgqN1SYvr/rkgqN1SYvr.md

@@ -0,0 +1,530 @@
+# PROVABLE BENEFIT OF ORTHOGONAL INITIALIZATION IN OPTIMIZING DEEP LINEAR NETWORKS
+
+Wei Hu   
+Princeton University   
+huwei@cs.princeton.edu
+
+Lechao Xiao Google Brain xlc@google.com
+
+Jeffrey Pennington Google Brain jpennin@google.com
+
+# ABSTRACT
+
+The selection of initial parameter values for gradient-based optimization of deep neural networks is one of the most impactful hyperparameter choices in deep learning systems, affecting both convergence times and model performance. Yet despite significant empirical and theoretical analysis, relatively little has been proved about the concrete effects of different initialization schemes. In this work, we analyze the effect of initialization in deep linear networks, and provide for the first time a rigorous proof that drawing the initial weights from the orthogonal group speeds up convergence relative to the standard Gaussian initialization with iid weights. We show that for deep networks, the width needed for efficient convergence to a global minimum with orthogonal initializations is independent of the depth, whereas the width needed for efficient convergence with Gaussian initializations scales linearly in the depth. Our results demonstrate how the benefits of a good initialization can persist throughout learning, suggesting an explanation for the recent empirical successes found by initializing very deep non-linear networks according to the principle of dynamical isometry.
+
+# 1 INTRODUCTION
+
+Through their myriad successful applications across a wide range of disciplines, it is now well established that deep neural networks possess an unprecedented ability to model complex real-world datasets, and in many cases they can do so with minimal overfitting. Indeed, the list of practical achievements of deep learning has grown at an astonishing rate, and includes models capable of human-level performance in tasks such as image recognition (Krizhevsky et al., 2012), speech recognition (Hinton et al., 2012), and machine translation (Wu et al., 2016).
+
+Yet to each of these deep learning triumphs corresponds a large engineering effort to produce such a high-performing model. Part of the practical difficulty in designing good models stems from a proliferation of hyperparameters and a poor understanding of the general guidelines for their selection. Given a candidate network architecture, some of the most impactful hyperparameters are those governing the choice of the model’s initial weights. Although considerable study has been devoted to the selection of initial weights, relatively little has been proved about how these choices affect important quantities such as rate of convergence of gradient descent.
+
+In this work, we examine the effect of initialization on the rate of convergence of gradient descent in deep linear networks. We provide for the first time a rigorous proof that drawing the initial weights from the orthogonal group speeds up convergence relative to the standard Gaussian initialization with iid weights. In particular, we show that for deep networks, the width needed for efficient convergence for orthogonal initializations is independent of the depth, whereas the width needed for efficient convergence of Gaussian networks scales linearly in the depth.
+
+Orthogonal weight initializations have been the subject of a significant amount of prior theoretical and empirical investigation. For example, in a line of work focusing on dynamical isometry, it was found that orthogonal weights can speed up convergence for deep linear networks (Saxe et al., 2014; Advani & Saxe, 2017) and for deep non-linear networks (Pennington et al., 2018; Xiao et al., 2018; Gilboa et al., 2019; Chen et al., 2018; Pennington et al., 2017; Tarnowski et al., 2019; Ling & Qiu, 2019) when they operate in the linear regime. In the context of recurrent neural networks, orthogonality can help improve the system’s stability. A main limitation of prior work is that it has focused almost exclusively on model’s properties at initialization. In contrast, our analysis focuses on the benefit of orthogonal initialization on the entire training process, thereby establishing a provable benefit for optimization.
+
+The paper is organized as follows. After reviewing related work in Section 2 and establishing some preliminaries in Section 3, we present our main positive result on efficient convergence from orthogonal initialization in Section 4. In Section 5, we show that Gaussian initialization leads to exponentially long convergence time if the width is too small compared with the depth. In Section 6, we perform experiments to support our theoretical results.
+
+# 2 RELATED WORK
+
+Deep linear networks. Despite the simplicity of their input-output maps, deep linear networks define high-dimensional non-convex optimization landscapes whose properties closely reflect those of their non-linear counterparts. For this reason, deep linear networks have been the subject of extensive theoretical analysis. A line of work (Kawaguchi, 2016; Hardt & Ma, 2016; Lu & Kawaguchi, 2017; Yun et al., 2017; Zhou & Liang, 2018; Laurent & von Brecht, 2018) studied the landscape properties of deep linear networks. Although it was established that all local minima are global under certain assumptions, these properties alone are still not sufficient to guarantee global convergence or to provide a concrete rate of convergence for gradient-based optimization algorithms.
+
+Another line of work directly analyzed the trajectory taken by gradient descent and established conditions that guarantee convergence to global minimum (Bartlett et al., 2018; Arora et al., 2018; Du & Hu, 2019). Most relevant to our work is the result of Du & Hu (2019), which shows that if the width of hidden layers is larger than the depth, gradient descent with Gaussian initialization can efficiently converge to a global minimum. Our result establishes that for Gaussian initialization, this linear dependence between width and depth is necessary, while for orthogonal initialization, the width can be independent of depth. Our negative result for Gaussian initialization also significantly generalizes the result of Shamir (2018), who proved a similar negative result for 1-dimensional linear networks.
+
+Orthogonal weight initializations. Orthogonal weight initializations have also found significant success in non-linear networks. In the context of feedforward models, the spectral properties of a network’s input-output Jacobian have been empirically linked to convergence speed (Saxe et al., 2014; Pennington et al., 2017; 2018; Xiao et al., 2018). It was found that when this spectrum concentrates around 1 at initialization, a property dubbed dynamical isometry, convergence times improved by orders of magnitude. The conditions for attaining dynamical isometry in the infinitewidth limit were established by Pennington et al. (2017; 2018) and basically require that input-output map to be approximately linear and for the weight matrices to be orthogonal. Therefore the training time benefits of dynamical isometry are likely rooted in the benefits of orthogonality for deep linear networks, which we establish in this work.
+
+Orthogonal matrices are also frequently used in the context of recurrent neural networks, for which the stability of the state-to-state transition operator is determined by the spectrum of its Jacobian (Haber & Ruthotto, 2017; Laurent & von Brecht, 2016). Orthogonal matrices can improve the conditioning, leading to an ability to learn over long time horizons (Le et al., 2015; Henaff et al., 2016; Chen et al., 2018; Gilboa et al., 2019). While the benefits of orthogonality can be quite large at initialization, little is known about whether or in what contexts these benefits persist during training, a scenario that has lead to the development of efficient methods of constraining the optimization to the orthogonal group (Wisdom et al., 2016; Vorontsov et al., 2017; Mhammedi et al., 2017). Although we do not study the recurrent setting in this work, an extension of our analysis might help determine when orthogonality is beneficial in that setting.
+
+# 3 PRELIMINARIES
+
+# 3.1 NOTATION
+
+Let $[ n ] = \{ 1 , 2 , \dots , n \}$ . Denote by $I _ { d }$ the $d \times d$ identity matrix, and by $I$ an identity matrix when its dimension is clear from context. Denote by ${ \mathcal { N } } ( \mu , \sigma ^ { 2 } )$ the Gaussian distribution with mean $\mu$ and variance $\sigma ^ { 2 }$ , and by $\chi _ { k } ^ { 2 }$ the chi-squared distribution with $k$ degrees of freedom.
+
+Denote by $\lVert \cdot \rVert$ the $\ell _ { 2 }$ norm of a vector or the spectral norm of a matrix. Denote by $\left\| \cdot \right\| _ { F }$ the Frobenius norm of a matrix. For a symmetric matrix $A$ , let $\lambda _ { \mathrm { m a x } } ( A )$ and $\lambda _ { \mathrm { m i n } } ( A )$ be its maximum and minimum eigenvalues, and let $\lambda _ { i } ( A )$ be its $i$ -th largest eigenvalue. For a matrix $B \in \mathbb { R } ^ { m \times n }$ , let $\sigma _ { i } ( B )$ be its $i$ -th largest singular value $( i = 1 , 2 , \ldots , \operatorname* { m i n } \{ m , n \} )$ , and let $\sigma _ { \mathrm { m a x } } ( B ) = \sigma _ { 1 } ( B )$ , $\sigma _ { \mathrm { m i n } } ( B ) = \sigma _ { \mathrm { m i n } \{ m , n \} } ( B )$ . Denote by vec $( A )$ be the vectorization of a matrix $A$ in column-first order. The Kronecker product between two matrices $A \in \mathbb { R } ^ { m _ { 1 } \times n _ { 1 } }$ and $B \in \mathbb { R } ^ { m _ { 2 } \times n _ { 2 } }$ is defined as
+
+$$
+A \otimes B = \left( \begin{array} { c c c } { a _ { 1 , 1 } B } & { \cdots } & { a _ { 1 , n _ { 1 } } B } \\ { \vdots } & { \ddots } & { \vdots } \\ { a _ { m _ { 1 } , 1 } B } & { \cdots } & { a _ { m _ { 1 } , n _ { 1 } } B } \end{array} \right) \in \mathbb { R } ^ { m _ { 1 } m _ { 2 } \times n _ { 1 } n _ { 2 } } ,
+$$
+
+where $a _ { i , j }$ is the element in the $( i , j )$ -th entry of $A$ .
+
+We use the standard $O ( \cdot ) , \Omega ( \cdot )$ and $\Theta ( \cdot )$ notation to hide universal constant factors. We also use $C$ to represent a sufficiently large universal constant whose specific value can differ from line to line.
+
+# 3.2 PROBLEM SETUP
+
+Suppose that there are $n$ training examples $\{ ( x _ { k } , y _ { k } ) \} _ { k = 1 } ^ { n } \subset \mathbb { R } ^ { d _ { x } } \times \mathbb { R } ^ { d _ { y } }$ . Denote by $\boldsymbol { X } \ =$ $( x _ { 1 } , \ldots , x _ { n } ) \in \mathbb { R } ^ { d _ { x } \times n }$ the input data matrix and by $Y = ( y _ { 1 } , \dots , y _ { n } ) \in \mathbb { R } ^ { d _ { y } \times n }$ the target matrix. Consider an $L$ -layer linear neural network with weight matrices $W _ { 1 } , \dots , W _ { L }$ , which given an input $x \in \mathbb { R } ^ { d _ { x } }$ computes
+
+$$
+\begin{array} { r } { f ( x ; W _ { 1 } , \dots , W _ { L } ) = \alpha W _ { L } W _ { L - 1 } \cdot \cdot \cdot W _ { 1 } x , } \end{array}
+$$
+
+where $W _ { i } \in \mathbb { R } ^ { d _ { i } \times d _ { i - 1 } } ( i = 1 , \dots , L )$ , $d _ { 0 } = d _ { x }$ , $d _ { L } = d _ { y }$ , and $\alpha$ is a normalization constant which will be specified later according to the initialization scheme. We study the problem of training the deep linear network by minimizing the $\ell _ { 2 }$ loss over training data:
+
+$$
+\ell ( W _ { 1 } , \ldots , W _ { L } ) = { \frac { 1 } { 2 } } \sum _ { k = 1 } ^ { n } \left\| f ( x _ { k } ; W _ { 1 } , \ldots , W _ { L } ) - y _ { k } \right\| ^ { 2 } = { \frac { 1 } { 2 } } \left\| \alpha W _ { L } \cdots W _ { 1 } X - Y \right\| _ { F } ^ { 2 } .
+$$
+
+The algorithm we consider to minimize the objective (2) is gradient descent with random initialization, which first randomly samples the initial weight matrices $\{ W _ { i } ( 0 ) \} _ { i = 1 } ^ { L }$ from a certain distribution, and then updates the weights using gradient descent: for time $t = 0 , 1 , 2 , \ldots$ ,
+
+$$
+W _ { i } ( t + 1 ) = W _ { i } ( t ) - \eta \frac { \partial \ell } { \partial W _ { i } } ( W _ { 1 } ( t ) , \ldots , W _ { L } ( t ) ) , \qquad i \in [ L ] ,
+$$
+
+where $\eta > 0$ is the learning rate.
+
+For convenience, we denote $W _ { j : i } = W _ { j } W _ { j - 1 } \cdot \cdot \cdot W _ { i }$ $1 \leq i \leq j \leq L )$ and $W _ { i - 1 : i } = I \left( i \in [ L ] \right)$ . The time index $t$ is used on any variable that depends on $W _ { 1 } , \dots , W _ { L }$ to represent its value at time $t$ , e.g., $W _ { j : i } ( t ) = W _ { j } ( t ) \cdot \cdot \cdot W _ { i } ( t ) , \ell ( t ) = \ell ( W _ { 1 } ( t ) , \ldots , W _ { L } ( t ) )$ , etc.
+
+# 4 EFFICIENT CONVERGENCE USING ORTHOGONAL INITIALIZATION
+
+In this section we present our main positive result for orthogonal initialization. We show that orthogonal initialization enables efficient convergence of gradient descent to a global minimum provided that the hidden width is not too small.
+
+In order to properly define orthogonal weights, we let the widths of all hidden layers be equal: $d _ { 1 } = d _ { 2 } = \cdot \cdot \cdot = d _ { L - 1 } = m$ , and let $m ^ { - } \geq \operatorname* { m a x } \{ d _ { x } , d _ { y } \}$ . Note that all intermediate matrices
+
+$W _ { 2 } , \ldots , W _ { L - 1 }$ are $m \times m$ square matrices, and $W _ { 1 } \in \mathbb { R } ^ { m \times d _ { x } }$ , $W _ { L } \in \mathbb { R } ^ { d _ { y } \times m }$ . We sample each initial weight matrix $W _ { i } ( 0 )$ independently from a uniform distribution over scaled orthogonal matrices satisfying
+
+$$
+\begin{array} { r l } & { W _ { 1 \ } ^ { \top } ( 0 ) W _ { 1 } ( 0 ) = m I _ { d _ { x } } , } \\ & { W _ { i \ } ^ { \top } ( 0 ) W _ { i } ( 0 ) = W _ { i } ( 0 ) W _ { i \ } ^ { \top } ( 0 ) = m I _ { m } , \qquad 2 \leq i \leq L - 1 , } \\ & { W _ { L } ( 0 ) W _ { L \ } ^ { \top } ( 0 ) = m I _ { d _ { y } } . } \end{array}
+$$
+
+In accordance with such initialization, the scaling factor $\alpha$ in (1) is set as $\begin{array} { r } { \alpha = \frac { 1 } { \sqrt { m ^ { L - 1 } d _ { y } } } } \end{array}$ , which ensures $\mathbb { E } \left[ \| f ( x ; W _ { L } ( 0 ) , \ldots , W _ { 1 } ( 0 ) ) \| ^ { 2 } \right] = \| x \| ^ { 2 }$ for any $x \in \mathbb { R } ^ { d _ { x } }$ .1 The same scaling factor was adopted in Du & Hu (2019), which preserves the expectation of the squared $\ell _ { 2 }$ norm of any input.
+
+Let $\begin{array} { r } { W ^ { * } \in \mathop { \mathrm { a r g } } \operatorname* { m i n } _ { W \in \mathbb { R } ^ { d _ { y } \times d _ { x } } } \left. W X - Y \right. _ { F } } \end{array}$ and $\begin{array} { r } { \ell ^ { * } = \frac { 1 } { 2 } \left. W ^ { * } X - Y \right. _ { F } ^ { 2 } } \end{array}$ . Then $\ell ^ { * }$ is the minimum value for the objective (2). Denote $r = \mathrm { r a n k } ( X )$ , $\begin{array} { r } { \kappa = \frac { \lambda _ { \operatorname* { m a x } } ( X ^ { \top } X ) } { \lambda _ { r } ( X ^ { \top } X ) } } \end{array}$ , and $\tilde { r } = \frac { \| X \| _ { F } ^ { 2 } } { \| X \| ^ { 2 } }$ .2 Our main theorem in this section is the following:
+
+Theorem 4.1. Suppose
+
+$$
+m \geq C \cdot \tilde { r } \kappa ^ { 2 } \left( d _ { y } ( 1 + \left. W ^ { * } \right. ^ { 2 } ) + \log ( r / \delta ) \right) \ a n d m \geq d _ { x } ,
+$$
+
+for some $\delta \in ( 0 , 1 )$ and a sufficiently large universal constant $C > 0$ . Set the learning rate $\eta \leq$ dy2LkXk2 . Then with probability at least 1 − δ over the random initialization, we have
+
+$$
+\begin{array} { r l } & { \ell ( 0 ) - \ell ^ { * } \leq O \left( 1 + \frac { \log \left( r / \delta \right) } { d _ { y } } + \left. W ^ { * } \right. ^ { 2 } \right) \left. X \right. _ { F } ^ { 2 } , } \\ & { \ell ( t ) - \ell ^ { * } \leq \left( 1 - \frac { 1 } { 2 } \eta L \lambda _ { r } ( X ^ { \top } X ) / d _ { y } \right) ^ { t } ( \ell ( 0 ) - \ell ^ { * } ) , \quad t = 0 , 1 , 2 , \ldots , } \end{array}
+$$
+
+where $\ell ( t )$ is the objective value at iteration $t$ .
+
+Notably, in Theorem 4.1, the width $m$ need not depend on the depth $L$ . This is in sharp contrast with the result of Du & Hu (2019) for Gaussian initialization, which requires $m \geq \tilde { \Omega } ( L r \kappa ^ { 3 } d _ { y } )$ . It turns out that a near-linear dependence between $m$ and $L$ is necessary for Gaussian initialization to have efficient convergence, as we will show in Section 5. Therefore the requirement in $\mathrm { D u }$ & $\mathrm { H u }$ (2019) is nearly tight in terms of the dependence on $L$ . These results together rigorously establish the benefit of orthogonal initialization in optimizing very deep linear networks.
+
+If we set the learning rate optimally according to Theorem 4.1 to $\begin{array} { r } { \eta = \Theta \big ( \frac { d _ { y } } { L \lVert X \rVert ^ { 2 } } \big ) } \end{array}$ ( dyLkXk2 ), we obtain that $\ell ( t ) - \ell ^ { * }$ decreases by a ratio of $1 - \Theta ( \kappa ^ { - 1 } )$ after every iteration. This matches the convergence rate of gradient descent on the (1-layer) linear regression problem $\operatorname* { m i n } _ { W \in \mathbb { R } ^ { d _ { y } \times d _ { x } } } \frac { 1 } { 2 } \left\| W X - Y \right\| _ { F } ^ { 2 } .$ .
+
+# 4.1 PROOF OF THEOREM 4.1
+
+The proof uses the high-level framework from Du & $\mathrm { H u }$ (2019), which tracks the evolution of the network’s output during optimization. This evolution is closely related to a time-varying positive semidefinite (PSD) matrix (defined in (7)), and the proof relies on carefully upper and lower bounding the eigenvalues of this matrix throughout training, which in turn implies the desired convergence result.
+
+First, we can make the following simplifying assumption without loss of generality. See Appendix B in Du & Hu (2019) for justification.
+
+Assumption 4.1. (Without loss of generality) $X \in \mathbb { R } ^ { d _ { x } \times r }$ , $\operatorname { r a n k } ( X ) = r$ , $Y = W ^ { * } X$ , and $\ell ^ { * } = 0$
+
+Now we briefly review Du & $\mathrm { H u }$ (2019)’s framework. The key idea is to look at the network’s output, defined as
+
+$$
+U = \alpha W _ { L : 1 } X \in \mathbb { R } ^ { d _ { y } \times n } .
+$$
+
+We also write $U ( t ) = \alpha W _ { L : 1 } ( t ) X$ as the output at time $t$ . Note that $\ell ( t ) = \textstyle { \frac { 1 } { 2 } } \left\| { U ( t ) - Y } \right\| _ { F } ^ { 2 }$ . According to the gradient descent update rule, we write
+
+$$
+V _ { L : 1 } ( t + 1 ) = \prod _ { i } \left( W _ { i } ( t ) - \eta \frac { \partial \ell } { \partial W _ { i } } ( t ) \right) = W _ { L : 1 } ( t ) - \sum _ { i = 1 } ^ { L } \eta W _ { L : i + 1 } ( t ) \frac { \partial \ell } { \partial W _ { i } } ( t ) W _ { i - 1 : 1 } ( t ) + E ( t ) ,
+$$
+
+where $E ( t )$ contains all the high-order terms (i.e., those with $\eta ^ { 2 }$ or higher). With this definition, the evolution of $U ( t )$ can be written as the following equation:
+
+$$
+\operatorname { v e c } \left( U ( t + 1 ) - U ( t ) \right) = - \eta P ( t ) \cdot \operatorname { v e c } \left( U ( t ) - Y \right) + \alpha \cdot \operatorname { v e c } \left( E ( t ) X \right) ,
+$$
+
+where
+
+$$
+P ( t ) = \alpha ^ { 2 } \sum _ { i = 1 } ^ { L } \Big [ \left( \left( W _ { i - 1 : 1 } ( t ) X \right) ^ { \top } \left( W _ { i - 1 : 1 } ( t ) X \right) \right) \otimes \left( W _ { L : i + 1 } ( t ) W _ { L : i + 1 } ^ { \top } ( t ) \right) \Big ] .
+$$
+
+Notice that $P ( t )$ is always PSD since it is the sum of $L$ PSD matrices. Therefore, in order to establish convergence, we only need to (i) show that the higher-order term $E ( t )$ is small and (ii) prove upper and lower bounds on $P ( t )$ ’s eigenvalues. For the second task, it suffices to control the singular values of $W _ { i - 1 : 1 } ( t )$ and $\bar { W } _ { L : i + 1 } ( t ) \ ( i \in [ L ] )$ .3 Under orthogonal initialization, these matrices are perfectly isometric at initialization, and we will show that they stay close to isometry during training, thus enabling efficient convergence.
+
+The following lemma summarizes some properties at initialization.
+
+Lemma 4.2. At initialization, we have
+
+$$
+\sigma _ { \operatorname* { m a x } } ( W _ { j : i } ( 0 ) ) = \sigma _ { \operatorname* { m i n } } ( W _ { j : i } ( 0 ) ) = m ^ { \frac { j - i + 1 } { 2 } } , \forall 1 \leq i \leq j \leq L , ( i , j ) \neq ( 1 , L ) .
+$$
+
+Furthermore, with probability at least $1 - \delta$ , the loss at initialization satisfies
+
+$$
+\ell ( 0 ) \leq O \left( 1 + \frac { \log ( r / \delta ) } { d _ { y } } + \left\| W ^ { * } \right\| ^ { 2 } \right) \left\| X \right\| _ { F } ^ { 2 } .
+$$
+
+Proof sketch. The spectral property (8) follows directly from (4).
+
+To prove (9), we essentially need to upper bound the magnitude of the network’s initial output. This turns out to be equivalent to studying the magnitude of the projection of a vector onto a random lowdimensional subspace, which we can bound using standard concentration inequalities. The details are given in Appendix A.1. □
+
+Now we proceed to prove Theorem 4.1. We define $\begin{array} { r } { B = O \left( 1 + \frac { \log \left( r / \delta \right) } { d _ { y } } + \left. W ^ { * } \right. ^ { 2 } \right) \left. X \right. _ { F } ^ { 2 } } \end{array}$ which is the upper bound on $\ell ( 0 )$ from (9). Conditioned on (9) being satisfied, we will use induction on $t$ to prove the following three properties $\mathbf { \mathcal { A } } ( t ) , \mathbf { \mathcal { B } } ( t )$ and $\mathcal { C } ( t )$ for all $t = 0 , 1 , \ldots$ :
+
+$$
+\begin{array} { r l } & { \bullet \ A ( t ) \colon \ell ( t ) \leq \left( 1 - \frac { 1 } { 2 } \eta L \sigma _ { \operatorname* { m i n } } ^ { 2 } ( X ) / d _ { y } \right) ^ { t } \ell ( 0 ) \leq \left( 1 - \frac { 1 } { 2 } \eta L \sigma _ { \operatorname* { m i n } } ^ { 2 } ( X ) / d _ { y } \right) ^ { t } B . } \\ & { \bullet \ B ( t ) \colon \sigma _ { \operatorname* { m a x } } ( W _ { j : i } ( t ) ) \ \leq \ 1 . 1 m ^ { \frac { j - i + 1 } { 2 } } , \sigma _ { \operatorname* { m i n } } ( W _ { j : i } ( t ) ) \ \geq \ 0 . 9 m ^ { \frac { j - i + 1 } { 2 } } , \quad \forall 1 \ \leq \ i \leq \ j \ \leq \ } \\ & { L , ( i , j ) \neq ( 1 , L ) . } \\ & { \bullet \ \mathcal { C } ( t ) \colon \| W _ { i } ( t ) - W _ { i } ( 0 ) \| _ { F } \leq \frac { 8 \sqrt { B d _ { y } } \| X \| } { L \sigma _ { \operatorname* { m i n } } ^ { 2 } ( X ) } , \quad \forall 1 \leq i \leq L . } \end{array}
+$$
+
+$\mathcal { A } ( 0 )$ and $B ( 0 )$ are true according to Lemma 4.2, and $\mathcal { C } ( 0 )$ is trivially true. In order to prove $\boldsymbol { \mathcal { A } } ( t )$ , $B ( t )$ and $\mathcal { C } ( t )$ for all $t$ , we will prove the following claims for all $t \geq 0$ :
+
+Claim 4.3. $\begin{array} { r } { A ( 0 ) , \ldots , A ( t ) , B ( 0 ) , \ldots , B ( t ) \Longrightarrow { \mathcal { C } } ( t + 1 ) . } \end{array}$
+
+Claim 4.4. $\mathcal { C } ( t ) \Longrightarrow B ( t )$ .
+
+Claim 4.5. $\mathcal { A } ( t ) , \mathcal { B } ( t ) \Longrightarrow \mathcal { A } ( t + 1 )$ .
+
+The proofs of these claims are given in Appendix A. Notice that we finish the proof of Theorem 4.1 once we prove $\boldsymbol { \mathcal { A } } ( t )$ for all $t \geq 0$ .
+
+# 5 EXPONENTIAL CURSE OF GAUSSIAN INITIALIZATION
+
+In this section, we show that gradient descent with Gaussian random initialization necessarily suffers from a running time that scales exponentially with the depth of the network, unless the width becomes nearly linear in the depth. Since we mostly focus on the dependence of width and running time on depth, we will assume the depth $L$ to be sufficiently large.
+
+Recall that we want to minimize the objective $\ell ( W _ { 1 } , \dots , W _ { L } ) = \frac { 1 } { 2 } \left\| \alpha W _ { L : 1 } X - Y \right\| _ { F } ^ { 2 }$ by gradient descent. We assume $Y = W ^ { * } X$ for some $W ^ { * } \in \mathbb { R } ^ { d _ { y } \times d _ { x } }$ , so that the optimal objective value is 0. For convenience, we assume $\| X \| _ { F } = \Theta ( 1 )$ and $\| Y \| _ { F } = \Theta ( 1 )$ .
+
+Suppose that at layer $i \in [ L ]$ , every entry of $W _ { i } ( 0 )$ is sampled from $\mathcal { N } ( 0 , \sigma _ { i } ^ { 2 } )$ , and all weights in the network are independent. We set the scaling factor $\alpha$ such that the initial output of the network does not blow up exponentially (in expectation):
+
+$$
+\mathbb { E } \left[ \left. f ( x ; W _ { 1 } ( 0 ) , \ldots , W _ { L } ( 0 ) ) \right. ^ { 2 } \right] \leq L ^ { O ( 1 ) } \cdot \left. x \right. ^ { 2 } , \quad \forall x \in \mathbb { R } ^ { d _ { x } } .
+$$
+
+Note that $\begin{array} { r } { \mathbb { E } \left[ \| f ( x ; W _ { 1 } ( 0 ) , \dots , W _ { L } ( 0 ) ) \| ^ { 2 } \right] = \alpha ^ { 2 } \prod _ { i = 1 } ^ { L } ( d _ { i } \sigma _ { i } ^ { 2 } ) \left\| x \right\| ^ { 2 } } \end{array}$ . Thus (10) means
+
+$$
+\alpha ^ { 2 } \prod _ { i = 1 } ^ { L } ( d _ { i } \sigma _ { i } ^ { 2 } ) \leq L ^ { O ( 1 ) } .
+$$
+
+We also assume that the magnitude of initialization at each layer cannot vanish with depth:
+
+$$
+d _ { i } \sigma _ { i } ^ { 2 } \geq \frac { 1 } { L ^ { O ( 1 ) } } , \quad \forall i \in [ L ] .
+$$
+
+Note that the assumptions (10) and (11) are just sanity checks to rule out the obvious pathological cases – they are easily satisfied by all the commonly used initialization schemes in practice.
+
+Now we formally state our main theorem in this section.
+
+Theorem 5.1. Suppose $\operatorname* { m a x } \{ d _ { 0 } , d _ { 1 } , \dots , d _ { L } \} \le O ( L ^ { 1 - \gamma } )$ for some universal constant $0 < \gamma \leq 1$ . Then there exists a universal constant $c > 0$ such that, $i f$ gradient descent is run with learning rate $\eta \leq e ^ { c L ^ { \gamma } }$ , then with probability at least 0.9 over the random initialization, for the first $e ^ { \Omega ( L ^ { \gamma } ) }$ iterations, the objective value is stuck between $0 . 4 \left\| Y \right\| _ { F } ^ { 2 }$ and $0 . 6 \left\| Y \right\| _ { F } ^ { 2 }$ .
+
+Theorem 5.1 establishes that efficient convergence from Gaussian initialization is impossible for large depth unless the width becomes nearly linear in depth. This nearly linear dependence is the best we can hope for, since Du & Hu (2019) proved a positive result when the width is larger than linear in depth. Therefore, a phase transition from untrainable to trainable happens at the point when the width and depth has a nearly linear relation. Furthermore, Theorem 5.1 generalizes the result of Shamir (2018), which only treats the special case of $d _ { 0 } = \dots = d _ { L } = 1$ .
+
+# 5.1 PROOF OF THEOREM 5.1
+
+For convenience, we define a scaled version of $W _ { i }$ : let $A _ { i } = { W _ { i } } / { ( \sqrt { d _ { i } } \sigma _ { i } ) }$ and $\begin{array} { r } { \beta = \alpha \prod _ { i = 1 } ^ { L } ( \sqrt { d _ { i } } \sigma _ { i } ) } \end{array}$ Then we know $\beta \leq L ^ { O ( 1 ) }$ and $\alpha W _ { L : 1 } = \beta A _ { L : 1 }$ , where $A _ { j : i } = A _ { j } \cdot \cdot \cdot A _ { i }$ .
+
+We first give a simple upper bound on $\| A _ { j : i } ( 0 ) \|$ for all $1 \leq i \leq j \leq L$ .
+
+Lemma 5.2. With probability at least $1 - \delta$ , we have $\begin{array} { r } { \| A _ { j : i } ( 0 ) \| \le O \left( \frac { L ^ { 3 } } { \delta } \right) . } \end{array}$ for all $1 \leq i \leq j \leq L$
+
+The proof of Lemma 5.2 is given in Appendix B.1. It simply uses Markov inequality and union bound.
+
+Furthermore, a key property at initialization is that if $j - i$ is large enough, $\left\| A _ { j : i } ( 0 ) \right\|$ will become exponentially small.
+
+Lemma 5.3. With probability at least $1 - e ^ { - \Omega ( L ^ { \gamma } ) }$ , for all $1 \leq i \leq j \leq L$ such that $\begin{array} { r } { j - i \geq \frac { L } { 1 0 } } \end{array}$ , we have $\| A _ { j : i } ( 0 ) \| \le e ^ { - \Omega ( L ^ { \gamma } ) }$ .
+
+Proof. We first consider a fixed pair $( i , j )$ such that $\begin{array} { r } { j \mathrm { ~ - ~ } i \ge \frac { L } { 1 0 } } \end{array}$ . In order to bound $\| A _ { j : i } ( 0 ) \|$ , we first take an arbitrary unit vector $v \in \mathbb { R } ^ { d _ { i - 1 } }$ and bound $\| A _ { j : i } ( 0 ) v \|$ . We can write $\left\| A _ { j : i } ( 0 ) v \right\| ^ { 2 } =$ $\textstyle \prod _ { k = i } ^ { j } Z _ { k }$ , where $\begin{array} { r } { Z _ { k } = \frac { \| A _ { k : i } ( 0 ) v \| ^ { 2 } } { \| A _ { k - 1 : i } ( 0 ) v \| ^ { 2 } } } \end{array}$ . Note that for any nonzero $v ^ { \prime } \in \mathbb { R } ^ { d _ { k - 1 } }$ independent of $A _ { k } ( 0 )$ , the distribution of $d _ { k } \cdot \frac { \left\| A _ { k } ( 0 ) v ^ { \prime } \right\| ^ { 2 } } { \| v ^ { \prime } \| ^ { 2 } }$ is $\chi _ { d _ { k } } ^ { 2 }$ . Therefore, $Z _ { i } , \ldots , Z _ { j }$ are independent, and $d _ { k } Z _ { k } \sim \chi _ { d _ { k } } ^ { 2 }$ $( k = i , i + 1 , \dotsc , j )$ . Recall the expression for the moments of chi-squared random variables: $\begin{array} { r } { \mathbb { E } \left[ Z _ { k } ^ { \lambda } \right] = \frac { 2 ^ { \lambda } \Gamma ( d _ { k } / 2 + \lambda ) } { d _ { k } ^ { \lambda } \Gamma ( d _ { k } / 2 ) } } \end{array}$ $( \forall \lambda > 0 )$ . Taking $\begin{array} { r } { \lambda = \frac { 1 } { 2 } } \end{array}$ and using the bound $\begin{array} { r } { \frac { \Gamma ( a + \frac { \mathrm { \bar { 1 } } } { 2 } ) } { \Gamma ( a ) } \leq \sqrt { a - 0 . 1 } ( \forall a \geq \frac { 1 } { 2 } ) } \end{array}$ (Qi & Luo, 2012), we get $\begin{array} { r } { \mathbb { E } \left[ \sqrt { Z _ { k } } \right] \le \sqrt { \frac { 2 ( d _ { k } / 2 - 0 . 1 ) } { d _ { k } } } = \sqrt { 1 - \frac { 0 . 2 } { d _ { k } } } \le 1 - \frac { 0 . 1 } { d _ { k } } } \end{array}$ . Therefore we have $\begin{array} { r } { \beth \left[ \sqrt { \prod _ { k = i } ^ { j } Z _ { k } } \right] \leq \prod _ { k = i } ^ { j } \left( 1 - \frac { 0 . 1 } { d _ { k } } \right) \leq \left( 1 - \frac { 0 . 1 } { O ( L ^ { 1 - \gamma } ) } \right) ^ { j - i + 1 } \leq \left( 1 - \Omega ( L ^ { \gamma - 1 } ) \right) ^ { \frac { L } { 1 0 } } = e ^ { - \Omega ( L ^ { \gamma } ) } . } \end{array}$ Choose a sufficiently small constant $c ^ { \prime } \quad > \quad 0$ . By Markov inequality we have $\mathrm { P r } \left[ \sqrt { \prod _ { k = i } ^ { j } Z _ { k } } > e ^ { - c ^ { \prime } L ^ { \gamma } } \right] \leq e ^ { c ^ { \prime } L ^ { \gamma } } \mathbb { E } \left[ \sqrt { \prod _ { k = i } ^ { j } Z _ { k } } \right] \leq e ^ { c ^ { \prime } L ^ { \gamma } } e ^ { - \Omega ( L ^ { \gamma } ) } = e ^ { - \Omega ( L ^ { \gamma } ) }$ . Therefore we have shown that for any fixed unit vector $v \in \mathbb { R } ^ { d _ { i - 1 } }$ , with probability at least $1 - e ^ { - \Omega ( L ^ { \gamma } ) }$ we have $\| A _ { j : i } ( 0 ) v \| \leq e ^ { - \Omega ( L ^ { \gamma } ) }$ .
+
+Next, we use this to bound $\| A _ { j : i } ( 0 ) \|$ via an $\epsilon$ -net argument. We partition the index set $\left[ d _ { i - 1 } \right]$ into $[ d _ { i - 1 } ] = S _ { 1 } \cup S _ { 2 } \cup \dots \cup S _ { q }$ such that $| S _ { l } | \le L ^ { \gamma / 2 } \left( \forall l \in \left[ q \right] \right)$ and $\begin{array} { r } { q = O \big ( \frac { d _ { i - 1 } } { L ^ { \gamma / 2 } } \big ) } \end{array}$ . For each $l \in [ q ]$ , let $\mathcal { N } _ { l }$ be a $\frac { 1 } { 2 }$ -net for all the unit vectors in $\mathbb { R } ^ { d _ { i - 1 } }$ with support in $S _ { l }$ . Note that we can choose $\mathcal { N } _ { l }$ such that $\overline { { { | } } } \mathcal { N } _ { l } | = e ^ { O ( | S _ { l } | ) } = e ^ { O ( L ^ { \gamma / 2 } ) }$ . Taking a union bound over $\cup _ { l = 1 } ^ { q } { \mathcal { N } } _ { l }$ , we know that $\| A _ { j : i } ( 0 ) v \| \leq e ^ { - \Omega ( L ^ { \gamma } ) } \| v \|$ simultaneously for all $v \in \cup _ { l = 1 } ^ { q } \mathcal { N } _ { l }$ with probability at least $1 -$ $\begin{array} { r } { \left( \sum _ { l = 1 } ^ { q } | \mathcal { N } _ { l } | \right) e ^ { - \Omega ( L ^ { \gamma } ) } \geq 1 - q \cdot e ^ { O ( L ^ { \gamma / 2 } ) } e ^ { - \Omega ( L ^ { \gamma } ) } = 1 - e ^ { - \Omega ( L ^ { \gamma } ) } . } \end{array}$ .
+
+Now, for any $u \in \mathbb { R } ^ { d _ { i - 1 } }$ , we write it as $\begin{array} { r } { u = \sum _ { l = 1 } ^ { q } a _ { l } u _ { l } } \end{array}$ where $a _ { l }$ is a scalar and $u _ { l }$ is a unit vector supported on $S _ { l }$ . By the definition of $\textstyle { \frac { 1 } { 2 } }$ -net, for each $l \in [ q ]$ there exists $v _ { l } \in \mathcal { N } _ { l }$ such that $\begin{array} { r } { \| v _ { l } - u _ { l } \| \le \frac { 1 } { 2 } } \end{array}$ . We know that $\| A _ { j : i } ( 0 ) v _ { l } \| \leq e ^ { - \Omega ( L ^ { \gamma } ) } \| v _ { l } \|$ for all $l \in [ q ]$ . Let $\begin{array} { r } { v = \sum _ { l = 1 } ^ { q } a _ { l } v _ { l } } \end{array}$ . We have
+
+$$
+\begin{array} { r l } & { A _ { j \cdot i } ( 0 ) v \Vert \leq \sum _ { l = 1 } ^ { q } \left| a _ { l } \right| \cdot \left. A _ { j \cdot i } ( 0 ) v _ { l } \right. \leq \sum _ { l = 1 } ^ { q } \left| a _ { l } \right| \cdot e ^ { - \Omega ( L ^ { \tau } ) } \left. v _ { l } \right. \leq e ^ { - \Omega ( L ^ { \tau } ) } \sqrt { q \cdot \sum _ { l = 1 } ^ { q } a _ { l } ^ { 2 } \left. v _ { l } \right. ^ { 2 } } } \\ & { \qquad = \sqrt { q } e ^ { - \Omega ( L ^ { \tau } ) } \left. v \right. = e ^ { - \Omega ( L ^ { \tau } ) } \left. v \right. . } \end{array}
+$$
+
+Note that $\begin{array} { r } { \| u - v \| = \| \sum _ { l = 1 } ^ { q } a _ { l } ( u _ { l } - v _ { l } ) \| = \sqrt { \sum _ { l = 1 } ^ { q } a _ { l } ^ { 2 } \left\| u _ { l } - v _ { l } \right\| ^ { 2 } } \leq \sqrt { \frac { 1 } { 4 } \sum _ { l = 1 } ^ { q } a _ { l } ^ { 2 } } = \frac { 1 } { 2 } \| u \| , } \end{array}$ which implies $\begin{array} { r } { \| v \| \leq \frac { 3 } { 2 } \| u \| } \end{array}$ . Therefore we have
+
+$$
+\begin{array} { r l } & { \| A _ { j : i } ( 0 ) u \| \leq \| A _ { j : i } ( 0 ) v \| + \| A _ { j : i } ( 0 ) ( u - v ) \| \leq e ^ { - \Omega ( L ^ { \gamma } ) } \| v \| + \| A _ { j : i } ( 0 ) \| \cdot \| u - v \| } \\ & { \qquad \leq e ^ { - \Omega ( L ^ { \gamma } ) } \cdot \displaystyle \frac { 3 } { 2 } \| u \| + \| A _ { j : i } ( 0 ) \| \cdot \displaystyle \frac { 1 } { 2 } \| u \| = e ^ { - \Omega ( L ^ { \gamma } ) } \| u \| + \| A _ { j : i } ( 0 ) \| \cdot \displaystyle \frac { 1 } { 2 } \| u \| . } \end{array}
+$$
+
+The above inequality is valid for any $u \in \mathbb { R } ^ { d _ { i - 1 } }$ . Thus we can take the unit vector $u$ that maximizes $\| A _ { j : i } ( 0 ) u \|$ . This gives us $\| A _ { j : i } ( 0 ) \| \le e ^ { - \Omega ( L ^ { \gamma } ) } + \frac 1 2 \| A _ { j : i } ( 0 ) \|$ , which implies $\| A _ { j : i } ( 0 ) \| \le e ^ { - \Omega ( L ^ { \gamma } ) }$ .
+
+Finally, we take a union bound over all possible $( i , j )$ . The failure probaility is at most $L ^ { 2 } e ^ { - \Omega ( L ^ { \gamma } ) } =$ $e ^ { - \Omega ( L ^ { \gamma } ) }$ . □
+
+The following lemma shows that the properties in Lemmas 5.2 and 5.3 are still to some extent preserved after applying small perturbations on all the weight matrices.
+
+Lemma 5.4. Suppose that the initial weights satisfy $\| A _ { j : i } ( 0 ) \| \le { \cal O } ( L ^ { 3 } )$ for all $1 \leq i \leq j \leq L ,$ , and $\| A _ { j : i } ( 0 ) \| \le e ^ { - c _ { 1 } L ^ { \gamma } }$ if $\begin{array} { r } { j - i \geq \frac { L } { 1 0 } } \end{array}$ , where $c _ { 1 } > 0$ is a universal constant. Then for another set of matrices $A _ { 1 } , \ldots , A _ { L }$ satisfying $\| A _ { i } - A _ { i } ( 0 ) \| \le e ^ { - 0 . 6 c _ { 1 } L ^ { \gamma } }$ for all $i \in [ L ]$ , we must have
+
+$$
+\begin{array} { r l } & { \| A _ { j : i } \| \le O ( L ^ { 3 } ) , \quad \forall 1 \le i \le j \le L , } \\ & { \| A _ { j : i } \| \le O \left( e ^ { - c _ { 1 } L ^ { \gamma } } \right) , \quad \forall 1 \le i \le j \le L , j - i \ge \cfrac { L } { 4 } . } \end{array}
+$$
+
+Proof. It suffices to show that the difference $A _ { j : i } - A _ { j : i } ( 0 )$ is tiny. Let $\Delta _ { i } ~ = ~ A _ { i } - A _ { i } ( 0 )$ . We have $A _ { j : i } \ = \ ( A _ { j } ( 0 ) + \Delta _ { j } ) \cdot \cdot \cdot ( A _ { i + 1 } ( 0 ) + \ ' \Delta _ { i + 1 } ) \bar { ( } A _ { i } ( 0 ) + \Delta _ { i } ) .$ Expanding this product, except for the one term corresponding to $A _ { j : i } ( 0 )$ , every other term has the form $A _ { j : ( k _ { s } + 1 ) } ( 0 ) \ .$ $\Delta _ { k _ { s } } \cdot A _ { ( k _ { s } - 1 ) : ( k _ { s - 1 } + 1 ) } ( 0 ) \cdot \Delta _ { k _ { s - 1 } } \cdot \cdot \cdot \Delta _ { k _ { 1 } } \cdot A _ { ( k _ { 1 } - 1 ) : i } ( 0 )$ , where $i \ \leq \ k _ { 1 } \ < \ \cdot \ \cdot \ < \ k _ { s } \ \leq \ j$ . By assumption, each $\Delta _ { k }$ has spectral norm $e ^ { - 0 . 6 c _ { 1 } L ^ { \gamma } }$ , and each $A _ { j ^ { \prime } : i ^ { \prime } } ( 0 )$ has spectral norm $O ( L ^ { 3 } )$ , so we have $\begin{array} { r l } { \big \| \boldsymbol { A } _ { j ; ( k _ { s } + 1 ) } ( 0 ) \cdot \boldsymbol { \Delta } _ { k _ { s } } \cdot \boldsymbol { A } _ { ( k _ { s } - 1 ) ; ( k _ { s - 1 } + 1 ) } ( 0 ) \cdot \boldsymbol { \Delta } _ { k _ { s - 1 } } \cdot \cdot \cdot \boldsymbol { \Delta } _ { k _ { 1 } } \cdot \boldsymbol { A } _ { ( k _ { 1 } - 1 ) ; i } ( 0 ) \big \| } & { { } \leq \frac { \| \boldsymbol { A } _ { j ; ( k _ { s } - 1 ) } \| \cdot \| \boldsymbol { A } _ { k _ { s - 1 } } \| \cdot \| \boldsymbol { A } _ { k _ { s - 1 } } \| } { \| \boldsymbol { A } _ { k _ { s } - 1 } \| \cdot \| \boldsymbol { A } _ { k _ { s - 1 } } \| } } \end{array}$ $\left( e ^ { - 0 . 6 c _ { 1 } L ^ { \gamma } } \right) ^ { s } \left( O ( L ^ { 3 } ) \right) ^ { s + 1 }$ . Therefore we have
+
+$$
+\begin{array} { c l } { \displaystyle \lVert A _ { j : i } - A _ { j : i } ( 0 ) \rVert \le \displaystyle \sum _ { s = 1 } ^ { j - i + 1 } \left( \displaystyle j - i + 1 \right) \left( e ^ { - 0 . 6 \epsilon _ { 1 } L ^ { \tau } } \right) ^ { s } \left( O ( L ^ { 3 } ) \right) ^ { s + 1 } } & { \mathrm { ~ i ~ f ~ } } \\ { \displaystyle \le \sum _ { s = 1 } ^ { j - i + 1 } L ^ { s } \left( e ^ { - 0 . 6 \epsilon _ { 1 } L ^ { \tau } } \right) ^ { s } \left( O ( L ^ { 3 } ) \right) ^ { s + 1 } \le O ( L ^ { 3 } ) \sum _ { s = 1 } ^ { \infty } \left( O ( L ^ { 4 } ) e ^ { - 0 . 6 \epsilon _ { 1 } L ^ { \tau } } \right) ^ { s } \le O ( L ^ { 3 } ) \sum _ { s = 1 } ^ { \infty } ( 1 / 2 ) ^ { s } = O ( L ^ { 3 } ) \displaystyle \sum _ { s = 1 } ^ { \infty } \left( O ( L ^ { 3 } ) \right) ^ { s } , } & { \mathrm { ~ i ~ f ~ } \mathrm { ~ i ~ f ~ } \mathrm { ~ i ~ f ~ } \mathrm { ~ i ~ f ~ } } \\ { \displaystyle \le \sum _ { s = 1 } ^ { j - 1 } L ^ { s } \left( e ^ { - 0 . 6 \epsilon _ { 1 } L ^ { \tau } } \right) ^ { s } \left( O ( L ^ { 3 } ) \right) ^ { s + 1 } \le O ( L ^ { 3 } ) \sum _ { s = 1 } ^ { \infty } \left( O ( L ^ { 4 } ) e ^ { - 0 . 6 \epsilon _ { 1 } L ^ { \tau } } \right) ^ { s } \le O ( L ^ { 3 } ) \sum _ { s = 1 } ^ { \infty } ( 1 / 2 ) ^ { s } = O ( L ^ { 3 } ) \displaystyle \sum _ { s = 1 } ^ { \infty } \left( O ( L ^ { 3 } ) \right) ^ { s } , } & { \mathrm { ~ i ~ f ~ } \mathrm { ~ i ~ f ~ } \mathrm { ~ i ~ f ~ } \mathrm { ~ i ~ f ~ } } \\  \displaystyle \le \sum _ { s = 1 } ^ { j - 1 } L ^ { s } \left( e ^ { - 0 . 6 \epsilon _ { 1 } L ^ { \tau } } \right) ^ { s } \left( O ( L ^ { 3 } ) \right) ^ { s + 1 } \le O ( L ^ { 3 } ) \sum _ { s = 1 } ^ { \infty } \left( O ( L ^ { 4 } ) e ^ { - 0 . 6 \epsilon _ { 1 } L ^ { \tau } } \right) ^ { s } \le O ( L ^ { 3 } ) \sum _ { s = 1 } ^   \end{array}
+$$
+
+which implies $\| A _ { j : i } \| \le { \cal { O } } ( L ^ { 3 } )$ for all $1 \leq i \leq j \leq L$ .
+
+The proof of the second part of the lemma is postponed to Appendix B.2.
+
+As a consequence of Lemma 5.4, we can control the objective value and the gradient at any point sufficiently close to the random initialization.
+
+Lemma 5.5. For a set of weight matrices $W _ { 1 } , \dots , W _ { L }$ with $A _ { i } = W _ { i } / ( \sqrt { d _ { i } } \sigma _ { i } )$ that satisfy (12), the objective and the gradient satisfy
+
+$$
+\begin{array} { r l } & { 0 . 4 \left\| Y \right\| _ { F } ^ { 2 } < \ell ( W _ { 1 } , \ldots , W _ { L } ) < 0 . 6 \left\| Y \right\| _ { F } ^ { 2 } , } \\ & { \left\| \nabla _ { W _ { i } } \ell ( W _ { 1 } , \ldots , W _ { L } ) \right\| \le ( \sqrt { d _ { i } } \sigma _ { i } ) ^ { - 1 } e ^ { - 0 . 9 c _ { 1 } L ^ { \gamma } } , \quad \forall i \in [ L ] . } \end{array}
+$$
+
+The proof of Lemma 5.5 is given in Appendix B.3.
+
+Finally, we can finish the proof of Theorem 5.1 using the above lemmas.
+
+Proof of Theorem 5.1. From Lemmas 5.2 and 5.3, we know that with probability at least 0.9, we have (i) $\| A _ { j : i } ( 0 ) \| \le { \cal O } ( L ^ { 3 } )$ for all $1 \leq i \leq j \leq L$ , and (ii) $\left\| A _ { j : i } ( 0 ) \right\| \le e ^ { - c _ { 1 } \bar { L } ^ { \gamma } }$ if $( i , j )$ further satisfies $\begin{array} { r } { j - i \geq \frac { L } { 1 0 } } \end{array}$ . Here $c _ { 1 } > 0$ is a universal constant. From now on we are conditioned on these properties being satisfied. We suppose that the learning rate η is at most e0.2c1Lγ .
+
+We say that a set of weight matrices $W _ { 1 } , \dots , W _ { L }$ are in the “initial neighborhood” if $\lVert A _ { i } - \dot { A } _ { i } ( 0 ) \rVert \leq e ^ { - 0 . 6 c _ { 1 } L ^ { \gamma } }$ for all $i \in [ L ]$ . From Lemmas 5.4 and 5.5 we know that in the “initial neighborhood” the objective value is always between $0 . 4 \left\| Y \right\| _ { F } ^ { 2 }$ and $0 . 6 \left\| Y \right\| _ { F } ^ { 2 }$ . Therefore we have to escape the “initial neighborhood” in order to get the objective value out of this interval.
+
+Now we calculate how many iterations are necessary to escape the “initial neighborhood.” According to Lemma 5.5, inside the “initial neighborhood” each √ $W _ { i }$ can move at most $\eta ( \sqrt { d _ { i } } \sigma _ { i } ) ^ { - 1 } e ^ { - 0 . 9 c _ { 1 } L ^ { \gamma } }$ in one iteration by definition of the gradient descent algorithm. In order to√ leave the “initial neighborhood,” some $W _ { i }$ must satisfy $\lVert W _ { i } - W _ { i } ( 0 ) \rVert = \sqrt { d _ { i } } \sigma _ { i } \lVert A _ { i } - A _ { i } ( 0 ) \rVert >$ $\sqrt { d _ { i } } \sigma _ { i } e ^ { - 0 . 6 c _ { 1 } L ^ { \gamma } }$ . In order to move this amount, the number of iterations has to be at least
+
+$$
+\frac { \sqrt { d _ { i } } \sigma _ { i } e ^ { - 0 . 6 c _ { 1 } L ^ { \gamma } } } { \eta ( \sqrt { d _ { i } } \sigma _ { i } ) ^ { - 1 } e ^ { - 0 . 9 c _ { 1 } L ^ { \gamma } } } = \frac { d _ { i } \sigma _ { i } ^ { 2 } e ^ { 0 . 3 c _ { 1 } L ^ { \gamma } } } { \eta } \geq \frac { 1 } { L ^ { O ( 1 ) } } \cdot \frac { e ^ { 0 . 3 c _ { 1 } L ^ { \gamma } } } { e ^ { 0 . 2 c _ { 1 } L ^ { \gamma } } } \geq e ^ { \Omega ( L ^ { \gamma } ) } .
+$$
+
+This finishes the proof.
+
+![](images/7f6b168cdc105d50aeb9d92c4a132cf9a35671921964e3b9fd8a566f0688527d.jpg)  
+Figure 1: log \`(t)\`(0) at $t = 1 2 5 8$ and $t = 1 0 0 0 0$ , for different depth-width configurations and different initialization schemes. Darker color means smaller loss.
+
+# 6 EXPERIMENTS
+
+In this section, we provide empirical evidence to support the results in Sections 4 and 5. To study how depth and width affect convergence speed of gradient descent under orthogonal and Gaussian initialization schemes, we train a family of linear networks with their widths ranging from 10 to 1000 and depths from 1 to 700, on a fixed synthetic dataset $( X , Y )$ .4 Each network is trained using gradient descent staring from both Gaussian and orthogonal initializations. In Figure 1, We lay out the logarithm of the relative training loss $\frac { \ell ( t ) } { \ell ( 0 ) }$ , using heap-maps, at steps $t = 1 2 5 8$ and $t = 1 0 0 0 0$ . In each heat-map, each point represents the relative training loss of one experiment; the darker the color, the smaller the loss. Figure 1 clearly demonstrates a sharp transition from untrainable to trainable (i.e., from red to black) when we increase the width of the network:
+
+• for Gaussian initialization, this transition occurs across a contour characterized by a linear relation between width and depth;   
+• for orthogonal initialization, the transition occurs at a width that is approximately independent of the depth.
+
+These observations excellently verify our theory developed in Sections 4 and 5.
+
+To have a closer look into the training dynamics, we also plot “relative loss v.s. training time” for a variety of depth-width configurations. See Figure 2. There again we can clearly see that orthogonal initialization enables fast training at small width (independent of depth), and that the required width for Gaussian initialization depends on depth.
+
+![](images/a30c7c831935643d2e50cebab1bdb568b75df4f3d96c6e8ebae767c41b269ec8.jpg)  
+Figure 2: Relative loss v.s. training time. For each plot, we vary width from 50 (yellow) to 1200 (purple). Solid and dashed lines represent Gaussian (GS) and orthogonal (OT) initializations.
+
+# 7 CONCLUSION
+
+In this work, we studied the effect of the initialization parameter values of deep linear neural networks on the convergence time of gradient descent. We found that when the initial weights are iid Gaussian, the convergence time grows exponentially in the depth unless the width is at least as large as the depth. In contrast, when the initial weight matrices are drawn from the orthogonal group, the width needed to guarantee efficient convergence is in fact independent of the depth. These results establish for the first time a concrete proof that orthogonal initialization is superior to Gaussian initialization in terms of convergence time.
+
+# REFERENCES
+
+Madhu S Advani and Andrew M Saxe. High-dimensional dynamics of generalization error in neural networks. arXiv preprint arXiv:1710.03667, 2017.
+
+Sanjeev Arora, Nadav Cohen, Noah Golowich, and Wei Hu. A convergence analysis of gradient descent for deep linear neural networks. arXiv preprint arXiv:1810.02281, 2018.
+
+Peter Bartlett, Dave Helmbold, and Phil Long. Gradient descent with identity initialization efficiently learns positive definite linear transformations. In International Conference on Machine Learning, pp. 520–529, 2018.
+
+Minmin Chen, Jeffrey Pennington, and Samuel S Schoenholz. Dynamical isometry and a mean field theory of rnns: Gating enables signal propagation in recurrent neural networks. arXiv preprint arXiv:1806.05394, 2018.
+
+Simon Du and Wei Hu. Width provably matters in optimization for deep linear neural networks. In International Conference on Machine Learning, pp. 1655–1664, 2019.
+
+Dar Gilboa, Bo Chang, Minmin Chen, Greg Yang, Samuel S Schoenholz, Ed H Chi, and Jeffrey Pennington. Dynamical isometry and a mean field theory of lstms and grus. arXiv preprint arXiv:1901.08987, 2019.
+
+Eldad Haber and Lars Ruthotto. Stable architectures for deep neural networks. Inverse Problems, 34(1):014004, 2017.
+
+Moritz Hardt and Tengyu Ma. Identity matters in deep learning. International Conference on Learning Representations, 2016.
+
+Mikael Henaff, Arthur Szlam, and Yann LeCun. Recurrent orthogonal networks and long-memory tasks. arXiv preprint arXiv:1602.06662, 2016.
+
+Geoffrey Hinton, Li Deng, Dong Yu, George E. Dahl, Abdel-rahman Mohamed, Navdeep Jaitly, Andrew Senior, Vincent Vanhoucke, Patrick Nguyen, Tara N Sainath, et al. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal Processing Magazine, 29(6):82–97, 2012.
+
+Kenji Kawaguchi. Deep learning without poor local minima. In Advances in Neural Information Processing Systems, pp. 586–594, 2016.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012.
+
+Thomas Laurent and James von Brecht. A recurrent neural network without chaos. arXiv preprint arXiv:1612.06212, 2016.
+
+Thomas Laurent and James von Brecht. Deep linear networks with arbitrary loss: All local minima are global. In International Conference on Machine Learning, pp. 2908–2913, 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.
+
+Zenan Ling and Robert C Qiu. Spectrum concentration in deep residual learning: a free probability approach. IEEE Access, 7:105212–105223, 2019.
+
+Haihao Lu and Kenji Kawaguchi. Depth creates no bad local minima. arXiv preprint arXiv:1702.08580, 2017.
+
+Zakaria Mhammedi, Andrew Hellicar, Ashfaqur Rahman, and James Bailey. Efficient orthogonal parametrisation of recurrent neural networks using householder reflections. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 2401–2409. JMLR. org, 2017.
+
+Jeffrey Pennington, Samuel Schoenholz, and Surya Ganguli. Resurrecting the sigmoid in deep learning through dynamical isometry: theory and practice. In Advances in neural information processing systems, pp. 4785–4795, 2017.
+
+Jeffrey Pennington, Samuel S Schoenholz, and Surya Ganguli. The emergence of spectral universality in deep networks. arXiv preprint arXiv:1802.09979, 2018.
+
+Feng Qi and Qiu-Ming Luo. Bounds for the ratio of two gamma functions—from wendel’s and related inequalities to logarithmically completely monotonic functions. Banach Journal of Mathematical Analysis, 6(2):132–158, 2012.
+
+Andrew M Saxe, James L McClelland, and Surya Ganguli. Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. International Conference on Learning Representations, 2014.
+
+Ohad Shamir. Exponential convergence time of gradient descent for one-dimensional deep linear neural networks. arXiv preprint arXiv:1809.08587, 2018.
+
+Wojciech Tarnowski, Piotr Warchoł, Stanisław Jastrzbski, Jacek Tabor, and Maciej Nowak. Dynamical isometry is achieved in residual networks in a universal way for any activation function. In The 22nd International Conference on Artificial Intelligence and Statistics, pp. 2221–2230, 2019.
+
+Eugene Vorontsov, Chiheb Trabelsi, Samuel Kadoury, and Chris Pal. On orthogonality and learning recurrent networks with long term dependencies. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 3570–3578. JMLR. org, 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.
+
+Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V. Le, Mohammad Norouzi, Wolfgang Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, et al. Google’s neural machine translation system: Bridging the gap between human and machine translation. arXiv preprint arXiv:1609.08144, 2016.
+
+Lechao Xiao, Yasaman Bahri, Jascha Sohl-Dickstein, Samuel Schoenholz, and Jeffrey Pennington. Dynamical isometry and a mean field theory of cnns: How to train 10,000-layer vanilla convolutional neural networks. In International Conference on Machine Learning, pp. 5389–5398, 2018.
+
+Chulhee Yun, Suvrit Sra, and Ali Jadbabaie. Global optimality conditions for deep neural networks. arXiv preprint arXiv:1707.02444, 2017.
+
+Yi Zhou and Yingbin Liang. Critical points of linear neural networks: Analytical forms and landscape properties. 2018.
+
+# A PROOFS FOR SECTION 4
+
+# A.1 PROOF OF LEMMA 4.2
+
+Proof of Lemma 4.2. We only need to prove (9). We first upper bound the magnitude of the network’s initial output on any given input $x \in \mathbb { R } ^ { d _ { x } }$ . Let √ 1mL−1 WL−1:1(0) · x ∈ Rm. Then we have $\| z \| = \| x \|$ , and $\begin{array} { r } { f ( x ; W _ { 1 } ( 0 ) , \dots , W _ { L } ( 0 ) ) = \frac { 1 } { \sqrt { d _ { y } } } W _ { L } ( 0 ) \cdot z = \sqrt { \frac { m } { d _ { y } } } \cdot \frac { 1 } { \sqrt { m } } W _ { L } ( 0 ) \cdot z } \end{array}$ . Note that $\frac { 1 } { \sqrt { m } } W _ { L } ( 0 ) \cdot z$ is the (signed) projection of $z$ onto a random subspace in $\mathbb { R } ^ { m }$ of dimension $d _ { y }$ . Therefore $\begin{array} { r l r } {  { \| \frac { 1 } { \sqrt { m } } W _ { L } ( 0 ) \cdot z \| ^ { 2 } / \| z \| ^ { 2 } } } \end{array}$ has the same distribution as $\frac { g _ { 1 } ^ { 2 } + \dots + g _ { d _ { y } } ^ { 2 } } { g _ { 1 } ^ { 2 } + \dots + g _ { m } ^ { 2 } }$ , where $g _ { 1 } , \ldots , g _ { m }$ are i.i.d. samples from $\mathcal { N } ( 0 , 1 )$ . By the standard tail bounds for chi-squared distributions we have
+
+$$
+\begin{array} { r l } & { \operatorname* { P r } \bigg [ g _ { 1 } ^ { 2 } + \cdot \cdot \cdot + g _ { d _ { y } } ^ { 2 } \leq d _ { y } + 2 \sqrt { d _ { y } \log ( 1 / \delta ^ { \prime } ) } + 2 \log ( 1 / \delta ^ { \prime } ) \bigg ] \geq 1 - \delta ^ { \prime } , } \\ & { \operatorname* { P r } \big [ g _ { 1 } ^ { 2 } + \cdot \cdot \cdot + g _ { m } ^ { 2 } \geq m - 2 \sqrt { m \log ( 1 / \delta ^ { \prime } ) } \big ] \geq 1 - \delta ^ { \prime } . } \end{array}
+$$
+
+Let $\begin{array} { r } { \delta ^ { \prime } = \frac { \delta } { 2 r } } \end{array}$ . Note that $m > C \cdot \log ( r / \delta )$ . We know that with probability at least $\textstyle 1 - { \frac { \delta } { r } }$ we have
+
+$$
+\left\| \frac { 1 } { \sqrt { m } } W _ { L } ( 0 ) \cdot z \right\| ^ { 2 } / \left\| z \right\| ^ { 2 } \leq \frac { d _ { y } + 2 \sqrt { d _ { y } \log ( 2 r / \delta ) } + 2 \log ( 2 r / \delta ) } { m - 2 \sqrt { m \log ( 2 r / \delta ) } } = \frac { O ( d _ { y } + \log ( r / \delta ) ) } { \Omega ( m ) } ,
+$$
+
+which implies
+
+$$
+\begin{array} { l } { \displaystyle \left\| f ( x ; W _ { 1 } ( 0 ) , \dots , W _ { L } ( 0 ) ) \right\| ^ { 2 } = \frac { m } { d _ { y } } \left\| \frac { 1 } { \sqrt { m } } W _ { L } ( 0 ) \cdot z \right\| ^ { 2 } = \frac { m } { d _ { y } } \cdot O \left( \frac { d _ { y } + \log ( r / \delta ) } { m } \right) \left\| z \right\| ^ { 2 } } \\ { \displaystyle \qquad = O \left( 1 + \frac { \log ( r / \delta ) } { d _ { y } } \right) \left\| x \right\| ^ { 2 } . } \end{array}
+$$
+
+Finally, taking a union bound, we know that with probability at least $1 - \delta$ , the inequality (13) holds for every $x \in \{ x _ { 1 } , \ldots , x _ { r } \}$ , which implies
+
+$$
+\begin{array} { l } { \displaystyle ( 0 ) = \frac { 1 } { 2 } \sum _ { k = 1 } ^ { r } \| f ( x _ { k } ; W _ { 1 } ( 0 ) , \dots , W _ { L } ( 0 ) ) - y _ { k } \| ^ { 2 } \leq \sum _ { k = 1 } ^ { r } \left( \| f ( x _ { k } ; W _ { 1 } ( 0 ) , \dots , W _ { L } ( 0 ) ) \| ^ { 2 } + \| y _ { k } \| ^ { 2 } \right) } \\ { \displaystyle \quad \leq O \left( 1 + \frac { \log \left( r / \delta \right) } { d _ { y } } \right) \sum _ { k = 1 } ^ { r } \| x _ { k } \| ^ { 2 } + \sum _ { k = 1 } ^ { r } \| y _ { k } \| ^ { 2 } = O \left( 1 + \frac { \log \left( r / \delta \right) } { d _ { y } } \right) \| X \| _ { F } ^ { 2 } + \| Y \| _ { F } ^ { 2 } } \\ { \displaystyle \quad \leq O \left( 1 + \frac { \log \left( r / \delta \right) } { d _ { y } } + \| W ^ { * } \| ^ { 2 } \right) \| X \| _ { F } ^ { 2 } . } \end{array}
+$$
+
+# A.2 PROOF OF CLAIM 4.3
+
+Proof of Claim 4.3. Let $\begin{array} { r } { \gamma = \frac { 1 } { 2 } L \sigma _ { \operatorname* { m i n } } ^ { 2 } ( X ) / d _ { y } } \end{array}$ . From $\mathcal { A } ( 0 ) , \ldots , \mathcal { A } ( t )$ we have $\ell ( s ) \leq ( 1 - \eta \gamma ) ^ { s } B$ for all $0 \leq s \leq t$ . The gradient of the objective function (2) is $\begin{array} { r } { \frac { \partial \ell } { \partial W _ { i } } = \alpha W _ { L : i + 1 } ^ { \top } ( U - Y ) \left( W _ { i - 1 : 1 } X \right) ^ { \top } } \end{array}$ . Thus we can bound the gradient norm as follows for all $0 \leq s \leq t$ and all $i \in [ L ]$ :
+
+$$
+\begin{array} { r l } & { \quad \left\| \displaystyle \frac { \partial \ell } { \partial W _ { i } } ( s ) \right\| _ { F } \leq \alpha \left\| W _ { L : i + 1 } ( s ) \right\| \left\| U ( s ) - Y \right\| _ { F } \left\| W _ { i - 1 : 1 } ( s ) \right\| \left\| X \right\| } \\ & { \leq \displaystyle \frac { 1 } { \sqrt { m ^ { L - 1 } d _ { y } } } \cdot 1 . 1 m ^ { \frac { L - i } { 2 } } \cdot \sqrt { 2 \ell ( s ) } \cdot 1 . 1 m ^ { \frac { i - 1 } { 2 } } \left\| X \right\| \leq \displaystyle \frac { 2 \sqrt { ( 1 - \eta \gamma ) ^ { s } B } } { \sqrt { d _ { y } } } \left\| X \right\| , } \end{array}
+$$
+
+where we have used $B ( s )$ . Then for all $i \in [ L ]$ we have:
+
+$$
+\left\| { W _ { i } ( t + 1 ) - W _ { i } ( 0 ) } \right\| _ { F } \le \sum _ { s = 0 } ^ { t } \left\| { W _ { i } ( s + 1 ) - W _ { i } ( s ) } \right\| _ { F } = \sum _ { s = 0 } ^ { t } \left\| { \eta \frac { \partial \ell } { \partial W _ { i } } ( s ) } \right\| _ { F }
+$$
+
+$$
+\begin{array} { r l } & { \leq \eta \displaystyle \sum _ { s = 0 } ^ { t } \frac { 2 \sqrt { ( 1 - \eta \gamma ) ^ { s } B } } { \sqrt { d _ { y } } } \left\| X \right\| \leq \frac { 2 \eta \sqrt { B } } { \sqrt { d _ { y } } } \left\| X \right\| \displaystyle \sum _ { s = 0 } ^ { t - 1 } ( 1 - \eta \gamma / 2 ) ^ { s } \leq \frac { 2 \eta \sqrt { B } } { \sqrt { d _ { y } } } \left\| X \right\| \cdot \frac { 2 } { \eta \gamma } } \\ & { = \frac { 8 \sqrt { B d _ { y } } \left\| X \right\| } { L \sigma _ { \operatorname* { m i n } } ^ { 2 } ( X ) } . } \end{array}
+$$
+
+This proves $\mathcal { C } ( t + 1 )$ .
+
+# A.3 PROOF OF CLAIM 4.4
+
+Proof of Claim 4.4. Let $R = \frac { 8 \sqrt { B d _ { y } } \| X \| } { L \sigma _ { \operatorname* { m i n } } ^ { 2 } ( X ) }$ and $\Delta _ { i } = W _ { i } ( t ) - W _ { i } ( 0 ) ~ ( i \in [ L ] )$ . Then $\mathcal { C } ( t )$ means $\| \Delta _ { i } \| _ { F } \le R \left( \forall i \in [ L ] \right)$ .
+
+For $1 \leq i \leq j \leq L$ , we have
+
+$$
+W _ { j : i } ( t ) = ( W _ { j } ( 0 ) + \Delta _ { j } ) \cdot \cdot \cdot ( W _ { i } ( 0 ) + \Delta _ { i } ) .
+$$
+
+Expanding this product, each term except $W _ { j : i } ( 0 )$ has the form:
+
+$$
+W _ { j : ( k _ { s } + 1 ) } ( 0 ) \cdot \Delta _ { k _ { s } } \cdot W _ { ( k _ { s } - 1 ) : ( k _ { s - 1 } + 1 ) } ( 0 ) \cdot \Delta _ { k _ { s - 1 } } \cdot \cdot \cdot \Delta _ { k _ { 1 } } \cdot W _ { ( k _ { 1 } - 1 ) : i } ( 0 ) ,
+$$
+
+where $i \le k _ { 1 } < \dots < k _ { s } \le j$ are locations where terms like $\Delta _ { k _ { l } }$ are taken out. Note that every factor in (15) of the form $W _ { j ^ { \prime } : i ^ { \prime } } ( 0 )$ satisfies $\| W _ { j ^ { \prime } : i ^ { \prime } } ( 0 ) \| = m ^ { \frac { j ^ { \prime } - i ^ { \prime } + 1 } { 2 } }$ according to (8). Thus, we can bound the sum of all terms of the form (15) as
+
+$$
+\begin{array} { c } { { \displaystyle \| { \cal W } _ { j : i } ( t ) - { \cal W } _ { j : i } ( 0 ) \| \le \displaystyle \sum _ { s = 1 } ^ { j - i + 1 } \binom { j - i + 1 } { s } { \cal R } ^ { s } m ^ { \frac { j - i + 1 - s } { 2 } } = ( \sqrt m + { \cal R } ) ^ { j - i + 1 } - ( \sqrt m ) ^ { j - i + 1 } } } \\ { { = ( \sqrt m ) ^ { j - i + 1 } \left( \left( 1 + { \cal R } / \sqrt m \right) ^ { j - i + 1 } - 1 \right) \le ( \sqrt m ) ^ { j - i + 1 } \left( \left( 1 + { \cal R } / \sqrt m \right) ^ { { \cal L } } - 1 \right) \le 0 . 1 ( \sqrt m ) ^ { j - i + 1 } . } } \end{array}
+$$
+
+Here the last step uses $m > C ( L R ) ^ { 2 }$ which is implied by (5). Combined with (8), this proves $B ( t )$ .
+
+# A.4 PROOF OF CLAIM 4.5
+
+Proof of Claim 4.5. Recall that we have the dynamics (6) for $U ( t )$ . In order to establish convergence from (6) we need to prove upper and lower bounds on the eigenvalues of $P ( t )$ , as well as show that the high-order term $E ( t )$ is small. We will prove these using $B ( t )$ .
+
+Using the definition (7) and property $B ( t )$ , we have
+
+$$
+\begin{array} { r l } & { \lambda _ { \operatorname* { m a x } } ( P ( t ) ) \leq \alpha ^ { 2 } \displaystyle \sum _ { i = 1 } ^ { L } \lambda _ { \operatorname* { m a x } } \left( \left( W _ { i - 1 : 1 } ( t ) X \right) ^ { \top } \left( W _ { i - 1 : 1 } ( t ) X \right) \right) \cdot \lambda _ { \operatorname* { m a x } } \left( W _ { L : i + 1 } ( t ) W _ { L : i + 1 } ^ { \top } ( t ) \right) } \\ & { \qquad \leq \displaystyle \frac { 1 } { m ^ { L - 1 } d _ { y } } \displaystyle \sum _ { i = 1 } ^ { L } \left( 1 . 1 m ^ { \frac { i - 1 } { 2 } } \sigma _ { \operatorname* { m a x } } ( X ) \right) ^ { 2 } \left( 1 . 1 m ^ { \frac { L - i } { 2 } } \right) ^ { 2 } \leq 2 L \sigma _ { \operatorname* { m a x } } ^ { 2 } ( X ) / d _ { y } , } \\ & { \lambda _ { \operatorname* { m i n } } ( P ( t ) ) \geq \alpha ^ { 2 } \displaystyle \sum _ { i = 1 } ^ { L } \lambda _ { \operatorname* { m i n } } \left( \left( W _ { i - 1 : 1 } ( t ) X \right) ^ { \top } \left( W _ { i - 1 : 1 } ( t ) X \right) \right) \cdot \lambda _ { \operatorname* { m i n } } \left( W _ { L : i + 1 } ( t ) W _ { L : i + 1 } ^ { \top } ( t ) \right) } \\ & { \qquad \geq \displaystyle \frac { 1 } { m ^ { L - 1 } d _ { y } } \displaystyle \sum _ { i = 1 } ^ { L } \left( 0 . 9 m ^ { \frac { i - 1 } { 2 } } \sigma _ { \operatorname* { m i n } } ( X ) \right) ^ { 2 } \left( 0 . 9 m ^ { \frac { L - i } { 2 } } \right) ^ { 2 } \geq \frac { 3 } { 5 } L \sigma _ { \operatorname* { m i n } } ^ { 2 } ( X ) / d _ { y } . } \end{array}
+$$
+
+In the lower bound above, we make use of the following relation on dimensions: $m \ \geq \ d _ { x } \ \geq$ $r$ , which enables the inequality $\lambda _ { \operatorname* { m i n } } \left( \left( W _ { i - 1 : 1 } ( t ) X \right) ^ { \top } ( \dot { W _ { i - 1 : 1 } } ( t ) X ) \right) = \sigma _ { \operatorname* { m i n } } ^ { 2 } \left( W _ { i - 1 : 1 } ( t ) X \right) \geq$ $\sigma _ { \mathrm { m i n } } ^ { 2 } \left( W _ { i - 1 : 1 } ( t ) \right) \cdot \sigma _ { \mathrm { m i n } } ^ { 2 } ( X ) .$
+
+Next, we will prove the following bound on the high-order term $E ( t )$ :
+
+$$
+\frac { 1 } { \sqrt { m ^ { L - 1 } d _ { y } } } \left\| E ( t ) X \right\| _ { F } \leq \frac { 1 } { 6 } \eta \lambda _ { \operatorname* { m i n } } ( P _ { t } ) \left\| U ( t ) - Y \right\| _ { F } .
+$$
+
+Recall that $E ( t )$ is the sum of all high-order terms in the product
+
+$$
+W _ { L : 1 } ( t + 1 ) = \prod _ { i } \bigg ( W _ { i } ( t ) - \eta \frac { \partial \ell } { \partial W _ { i } } ( t ) \bigg ) .
+$$
+
+Same as (14), we have $\begin{array} { r } { \left\| \frac { \partial \ell } { \partial W _ { i } } ( t ) \right\| _ { F } \le \frac { 2 \sqrt { \ell ( t ) } \| X \| } { \sqrt { d _ { y } } } \left( \forall i \in [ L ] \right) . } \end{array}$ . Then we have
+
+$$
+\begin{array} { r l } & { \quad \frac { 1 } { \sqrt { m ^ { L - 1 } d _ { y } } } \| E ( t ) X \| _ { F } } \\ & { \leq \frac { 1 } { \sqrt { m ^ { L - 1 } d _ { y } } } \displaystyle \sum _ { s = 2 } ^ { L } \left( \frac { L } { s } \right) \left( \eta \cdot \frac { 2 \sqrt { \ell ( t ) } \| X \| } { \sqrt { d _ { y } } } \right) ^ { s } m ^ { \frac { L - s } { L - 1 } } \| X \| } \\ & { \leq \sqrt { \displaystyle \frac { m } { d _ { y } } } \| X \| \displaystyle \sum _ { s = 2 } ^ { L } L ^ { s } \left( \eta \cdot \frac { 2 \sqrt { \ell ( t ) } \| X \| } { \sqrt { d _ { y } } } \right) ^ { s } m ^ { - \frac { s } { L } } } \\ & { = \sqrt { \displaystyle \frac { m } { d _ { y } } } \| X \| \displaystyle \sum _ { s = 2 } ^ { L } \left( \frac { 2 \eta L \sqrt { \ell ( t ) } \| X \| } { \sqrt { m d _ { y } } } \right) ^ { s } } \end{array}
+$$
+
+From $\begin{array} { r } { \eta \leq \frac { d _ { y } } { 2 L \| X \| ^ { 2 } } } \end{array}$ dy2LkXk2 , we have $\begin{array} { r } { \frac { 2 \eta L \sqrt { \ell ( t ) } \| X \| } { \sqrt { m d _ { y } } } \leq \frac { \sqrt { d _ { y } \cdot \ell ( t ) } } { \sqrt { m } \| X \| } } \end{array}$ . Note that $\begin{array} { r } { m > C \cdot \frac { d _ { y } B } { \| X \| ^ { 2 } } \geq C \cdot \frac { d _ { y } \ell ( t ) } { \| X \| ^ { 2 } } } \end{array}$ . Thus we have
+
+$$
+\begin{array} { r l } & { \quad \frac { 1 } { \sqrt { m ^ { L - 1 } d _ { y } } } \left\| E ( t ) X \right\| _ { F } \leq \sqrt { \frac { m } { d _ { y } } } \left\| X \right\| \left( \frac { 2 \eta L \sqrt { \ell ( t ) } \left\| X \right\| } { \sqrt { m d _ { y } } } \right) ^ { 2 } \underset { s = 2 } { \overset { L - 2 } { \sum } } 0 . 5 ^ { s - 2 } } \\ & { \leq 2 \sqrt { \frac { m } { d _ { y } } } \left\| X \right\| \left( \frac { 2 \eta L \sqrt { \ell ( t ) } \left\| X \right\| } { \sqrt { m d _ { y } } } \right) ^ { 2 } \leq 2 \sqrt { \frac { m } { d _ { y } } } \left\| X \right\| \cdot \frac { 2 \eta L \sqrt { \ell ( t ) } \left\| X \right\| } { \sqrt { m d _ { y } } } \cdot \frac { \sqrt { d _ { y } \cdot \ell ( t ) } } { \sqrt { m } \left\| X \right\| } } \\ & { = \frac { 4 \eta L \left\| X \right\| \cdot \ell ( t ) } { \sqrt { m d _ { y } } } . } \end{array}
+$$
+
+It suffices to show that the above bound is at most $\begin{array} { r } { \frac { 1 } { 6 } \eta \lambda _ { \mathrm { m i n } } ( P _ { t } ) \left. U ( t ) - Y \right. _ { F } = \frac { 1 } { 6 } \eta \lambda _ { \mathrm { m i n } } ( P _ { t } ) \sqrt { 2 \ell ( t ) } . } \end{array}$ 6Since λmin(Pt) ≥ 35 Lσ2min(X)/dy, it suffices to have
+
+$$
+\frac { 4 \eta L \left\| X \right\| \cdot \ell ( t ) } { \sqrt { m d _ { y } } } \leq \frac { 1 } { 6 } \eta \cdot \frac { 3 L \sigma _ { \operatorname* { m i n } } ^ { 2 } ( X ) \sqrt { 2 \ell ( t ) } } { 5 d _ { y } } ,
+$$
+
+which is true since m > C · dyBkXk24 $\begin{array} { r } { m > C \cdot \frac { d _ { y } B \| X \| ^ { 2 } } { \sigma _ { \operatorname* { m i n } } ^ { 4 } ( X ) } \geq C \cdot \frac { d _ { y } \ell ( t ) \| X \| ^ { 2 } } { \sigma _ { \operatorname* { m i n } } ^ { 4 } ( X ) } } \end{array}$
+
+Finally, from (6) and $\begin{array} { r } { \eta \leq \frac { d _ { y } } { 2 L \| X \| ^ { 2 } } \leq \frac { 1 } { \lambda _ { \operatorname* { m a x } } ( P _ { t } ) } } \end{array}$ we have
+
+$$
+\begin{array} { r l } & { \quad \| U ( t + 1 ) - Y \| _ { F } = \| \mathrm { v e c } ( U ( t + 1 ) - Y ) \| } \\ & { = \left\| \left( I - \eta P ( t ) \right) \cdot \mathrm { v e c } \left( U ( t ) - Y \right) + \frac { 1 } { \sqrt { m ^ { \underline { { L } } } - 1 } d _ { y } } \mathrm { v e c } \left( E ( t ) X \right) \right\| } \\ & { \leq ( 1 - \eta \lambda _ { \operatorname* { m i n } } ( P ( t ) ) ) \| \mathrm { v e c } \left( U ( t ) - Y \right) \| + \frac { 1 } { \sqrt { m ^ { \underline { { L } } } - 1 } d _ { y } } \| E ( t ) X \| _ { F } } \\ & { \leq ( 1 - \eta \lambda _ { \operatorname* { m i n } } ( P ( t ) ) ) \| U ( t ) - Y \| _ { F } + \frac { 1 } { 6 } \eta \lambda _ { \operatorname* { m i n } } ( P _ { t } ) \| U ( t ) - Y \| _ { F } } \\ & { = \left( 1 - \frac { 5 } { 6 } \eta \lambda _ { \operatorname* { m i n } } ( P ( t ) ) \right) \| U ( t ) - Y \| _ { F } } \\ & { \leq \left( 1 - \frac { 1 } { 2 } \eta L \sigma _ { \operatorname* { m i n } } ^ { 2 } ( X ) / d _ { y } \right) \| U ( t ) - Y \| _ { F } . } \end{array}
+$$
+
+Therefore $\begin{array} { r } { \ell ( t + 1 ) \leq \left( 1 - \frac { 1 } { 2 } \eta L \sigma _ { \operatorname* { m i n } } ^ { 2 } ( X ) / d _ { y } \right) ^ { 2 } \ell ( t ) \leq \left( 1 - \frac { 1 } { 2 } \eta L \sigma _ { \operatorname* { m i n } } ^ { 2 } ( X ) / d _ { y } \right) \ell ( t ) } \end{array}$ . Combined with $\boldsymbol { \mathcal { A } } ( t )$ , this proves $\boldsymbol { \mathcal { A } } ( t + 1 )$ .
+
+# B PROOFS FOR SECTION 5
+
+# B.1 PROOF OF LEMMA 5.2
+
+Proof of Lemma 5.2. Notice that for any $1 \leq i \leq j \leq L$ we have $\mathbb { E } \left[ \left. A _ { j : i } ( 0 ) \right. _ { F } ^ { 2 } \right] = d _ { i - 1 }$ . Then by Markov inequality we have $\begin{array} { r } { \operatorname* { P r } \left[ \left\| A _ { j : i } ( 0 ) \right\| _ { F } ^ { 2 } \geq \frac { d _ { i - 1 } } { \delta / L ^ { 2 } } \right] \leq \delta / L ^ { 2 } } \end{array}$ . Taking a union bound, we know that with probability at least $1 - \delta$ , for all $1 \leq i \leq j \leq L$ simultaneously we have $\left| | A _ { j : i } ( 0 ) \right| | \ \leq$ $\begin{array} { r } { \| A _ { j : i } ( 0 ) \| _ { F } \le \frac { d _ { i - 1 } } { \delta / L ^ { 2 } } \le O ( L ^ { 3 } / \delta ) } \end{array}$ (note that $d _ { i - 1 } \leq O ( L ^ { 1 - \gamma } ) = O ( L ) )$ . □
+
+# B.2 PROOF OF LEMMA 5.4
+
+Proof of Lemma 5.4 (continued). For the second part of the lemma $\begin{array} { r } { ( j - i \geq \frac { L } { 4 } ) } \end{array}$ , we need to bound the terms of the form $A _ { j : k + 1 } ( 0 ) \cdot \Delta _ { k } \cdot A _ { k - 1 : i } ( 0 )$ more carefully. In fact, if $j - i \geq \frac { L } { 4 }$ , then $\begin{array} { r } { \operatorname* { m a x } \{ j - k - 1 , k - 1 - i \} \geq \frac { L } { 1 0 } } \end{array}$ , which by assumption means either $A _ { j : k + 1 } ( 0 )$ or $A _ { k - 1 : i } ( 0 )$ has spectral norm bounded by $e ^ { - c _ { 1 } L ^ { \gamma } }$ . This implies $\| A _ { j : k + 1 } ( 0 ) \cdot \Delta _ { k } \cdot A _ { k - 1 : i } ( 0 ) \| \leq e ^ { - c _ { 1 } L ^ { \gamma } } e ^ { - 0 . 6 c _ { 1 } L ^ { \gamma } }$ · $O ( L ^ { 3 } ) = e ^ { - 1 . 6 c _ { 1 } L ^ { \gamma } } \cdot O ( L ^ { 3 } )$ . Therefore we have
+
+$$
+\begin{array} { l } { \displaystyle | | A _ { j : i } - A _ { j : i } ( 0 ) | | \le ( j - i + 1 ) e ^ { - 1 . 6 \epsilon _ { 1 } L ^ { \gamma } } \cdot O ( L ^ { 3 } ) + \displaystyle \sum _ { s = 2 } ^ { j - i + 1 } (  \begin{array} { c } { j - i + 1 } \\ { s } \end{array} ) ( e ^ { - 0 . 6 \epsilon _ { 1 } L ^ { \gamma } } ) ^ { s } ( O ( L ^ { 3 } ) ) ^ { s + 1 } } \\ { \displaystyle \le e ^ { - \epsilon _ { 1 } L ^ { \gamma } } + \displaystyle \sum _ { s = 2 } ^ { \infty } L ^ { s } ( e ^ { - 0 . 6 \epsilon _ { 1 } L ^ { \gamma } } ) ^ { s } ( O ( L ^ { 3 } ) ) ^ { s + 1 } \le e ^ { - \epsilon _ { 1 } L ^ { \gamma } } + \displaystyle \sum _ { s = 2 } ^ { \infty } ( e ^ { - 0 . 5 \epsilon _ { 1 } L ^ { \gamma } } ) ^ { s } = O ( e ^ { - \epsilon _ { 1 } L ^ { \gamma } } ) . } \end{array}
+$$
+
+This implies $\left\| A _ { j : i } \right\| \leq O \left( e ^ { - c _ { 1 } L ^ { \gamma } } \right)$ .
+
+# B.3 PROOF OF LEMMA 5.5
+
+Proof of Lemma 5.5. We can bound the network’s output as
+
+$$
+\left\| \alpha W _ { L : 1 } ( 0 ) X \right\| _ { F } = \left\| \beta A _ { L : 1 } ( 0 ) X \right\| _ { F } \leq L ^ { O ( 1 ) } \cdot e ^ { - \Omega ( L ^ { \gamma } ) } \left\| X \right\| _ { F } = e ^ { - \Omega ( L ^ { \gamma } ) } .
+$$
+
+Thus the objective value $\ell ( W _ { 1 } , \dots , W _ { L } ) = \frac { 1 } { 2 } \left\| \alpha W _ { L : 1 } ( 0 ) X - Y \right\| _ { F } ^ { 2 }$ must be extremely close to ${ \frac { 1 } { 2 } } \left\| Y \right\| _ { F } ^ { 2 }$ for large $L$ , so $0 . 4 \left\| Y \right\| _ { F } ^ { 2 } < \ell ( W _ { 1 } , \ldots , W _ { L } ) < 0 . 6 \left\| Y \right\| _ { F } ^ { 2 }$ .
+
+As for the gradient, for any $i \in [ L ]$ we have
+
+$$
+\begin{array} { r l } & { \quad \left\| \nabla _ { W _ { i } } \ell ( W _ { 1 } , \ldots , W _ { L } ) \right\| = \left\| \alpha W _ { L : i + 1 } ^ { \top } \left( \alpha W _ { L : 1 } X - Y \right) X ^ { \top } W _ { i - 1 : 1 } ^ { \top } \right\| } \\ & { = \left\| \beta / ( \sqrt { d _ { i } } \sigma _ { i } ) \cdot A _ { L : i + 1 } ^ { \top } \left( \alpha W _ { L : 1 } X - Y \right) X ^ { \top } A _ { i - 1 : 1 } ^ { \top } \right\| \leq \displaystyle \frac { L ^ { O ( 1 ) } } { \sqrt { d _ { i } } \sigma _ { i } } \left\| A _ { L : i + 1 } \right\| \cdot O ( 1 ) \cdot \left\| A _ { i - 1 : 1 } \right\| . } \end{array}
+$$
+
+Using (12), and noting that either $L - i - 1$ or $i - 1$ is greater than $\frac { L } { 4 }$ , we have
+
+$$
+\begin{array} { r } { \| \nabla _ { W _ { i } } \ell ( W _ { 1 } , \ldots , W _ { L } ) \| \le \sigma _ { i } ^ { - 1 } L ^ { O ( 1 ) } \cdot O \left( e ^ { - c _ { 1 } L ^ { \gamma } } \right) \cdot O ( L ^ { 3 } ) \le ( \sqrt { d _ { i } } \sigma _ { i } ) ^ { - 1 } e ^ { - 0 . 9 c _ { 1 } L ^ { \gamma } } . } \end{array}
+$$