Add files using upload-large-folder tool

parse/train/BkgYPREtPr/BkgYPREtPr.md

@@ -0,0 +1,398 @@
+# Symplectic Recurrent Neural Networks
+
+Zhengdao Chen $^ { a , c }$ , Jianyu Zhang $^ { ^ { b , c } }$ , Martin Arjovsky $^ a$ , Léon Bottou $c , a$
+
+$^ { a }$ New York University, New York, USA $^ { b }$ Tianjin University, Tianjin, China $_ c$ Facebook AI Research, New York, USA
+
+# Abstract
+
+We propose Symplectic Recurrent Neural Networks (SRNNs) as learning algorithms that capture the dynamics of physical systems from observed trajectories. An SRNN models the Hamiltonian function of the system by a neural network and furthermore leverages symplectic integration, multiplestep training and initial state optimization to address the challenging numerical issues associated with Hamiltonian systems. We show SRNNs succeed reliably on complex and noisy Hamiltonian systems. We also show how to augment the SRNN integration scheme in order to handle stiff dynamical systems such as bouncing billiards.
+
+# 1 Introduction
+
+Can machines learn physical laws from data? A recent paper (Greydanus et al., 2019), Hamiltonian Neural Networks (HNN), proposes to do so representing the Hamiltonian function $H ( q , p )$ as a multilayer neural network. The partial derivatives of this network are then trained to match the time derivatives $\dot { p }$ and $\dot { q }$ observed along the trajectories in state space.
+
+The ordinary differential equations (ODEs) that express Hamiltonian dynamics are famous for both their mathematical elegance and their challenges to numerical integration techniques. Except maybe for the simplest Hamiltonian systems, discretization errors and measurement noise lead to quickly diverging trajectories. In other words, Hamiltonian systems can often be stiff, a concept that usually refers to differential equations where we have to take very small time-steps of integration so that the numerical solution remain stable (Lambert, 1991). A plethora of numerical integration methods, symplectic integrators, have been developed to respect the conserved quantities in Hamiltonian systems, thereby usually being more stable and structure-preserving than non-symplectic ones (Hairer et al., 2002). For example, the simplest symplectic integrator is the well-known leapfrog method, also known as the Stömer-Verlet integrator (Leimkuhler and Reich, 2005). However, even the best integrators remain severely challenged by phenomena as intuitive as a mechanical rebound or a slingshot effect, which are more severe forms of stiffness. Such numerical issues are almost doomed to conflict with the inherently approximate nature of a learning algorithm.
+
+In the first part of this paper, we propose Symplectic Recurrent Neural Networks (SRNNs), where $( i )$ the partial derivatives of the neural-network-parametrized Hamiltonian are integrated with the leapfrog integrator and where $( i i )$ the loss is back-propagated through the ODE integration over multiple time steps. We find that in the presence of observation noise, SRNN are far more usable than HNNs. Further improvements are achieved by simultaneously optimizing the initial state and the Hamiltionian network, presenting an interesting contrast to previous literature on the hardness of general initial state optimization (Peifer and Timmer, 2007). The optimization can be motivated from a maximum likelihood estimation perspective, and we provide heuristic arguments for why the initial state optimization is likely convex given the symplecticness of the system. Furthermore, experiments in the three-body problem show that the SRNN-trained Hamiltonian compensates for discretization errors and can even outperform numerically solving the ODE using the true Hamiltonian and the same time-step size. This could be of particular interest to researchers who study the application of machine learning to numerically solving differential equations.
+
+The second part of this paper focuses on perfect rebound as an example of the more severe form of stiffness. When a point mass rebounds without loss of energy on a perfectly rigid obstacle, the motion of the point mass is changed in ways that can be interpreted as an infinite force applied during an infinitesimal time. The precise timing of this event affects the trajectory of the point mass in ways that essentially make it impossible to merely simulate the Hamiltonian system on a predefined grid of time points. In order to address such events in learning, we augment the leapfrog integrator used in our SRNN with an additional trainable operator that models the rebound events and relates their occurrence to visual hints. Training such an augmented SRNN on observed trajectories not only learns the point mass dynamics but also learns the visual appearance of the obstacles.
+
+# 2 Related work
+
+Learning physics with neural networks A popular category of methods attempts to replicate the intuitive ways in which humans perceive simple physical interactions, identifying objects and learning how they relate to each other (Battaglia et al., 2016; Chang et al., 2016). Since such methods cannot be used for more general physical systems, another category of methods seeks to learn which differential equations govern the evolution of a physical system on the basis of observed trajectories. Brunton et al. (2016) assemble a small number of predefined primitives in order to find an algebraically simple solution. Lutter et al. (2019) use a neural network to model the Lagrangian function of a robotic system. Most closely related to ours, Greydanus et al. (2019) use a neural network to learn the Hamiltonian of the dynamical system in such a way that its partial derivatives match the time derivatives of the position and momentum variables, which are both assumed to be observed. Although the authors show success on a simple pendulum system, this approach does not perform well on a more complex system such as a three-body problem.
+
+ODE-based learning and recurrent neural networks (RNNs) To learn an ODE that underlies some observed time series data, Chen et al. (2018a) proposes to solve a neuralnetwork-parameterized ODE numerically and minimize the distance between the generated time series with the observed data. To save memory, they propose to use the adjoint ODE instead of back-propagating through the ODE solver. Using stability analysis of ODEs, Chang et al. (2019) propose the AntisymmetricRNN with better trainability. Niu et al. (2019) establish a correspondence between RNNs and ODEs, and propose an RNN architecture inspired by a universal quantum computation scheme.
+
+Summary of our main contributions: In this paper, we propose SRNN, which • learns Hamiltonian dynamics directly from position and momentum time series • performs well on noisy and complex systems such as a spring-chain system and a three-body system, and is compatible with initial state optimzation • is augmented to handle perfect rebound, an example of very stiff Hamiltonian dynamics
+
+# 3 Framework
+
+# 3.1 Hamiltonian systems
+
+A Hamiltonian system of dimension $d$ is described by two vectors $p , q \in \mathbb { R } ^ { d }$ . Typically, they correspond to the momentum and position variables, respectively. The evolution of the system is determined by the Hamiltonian function $H : ( p , q , t ) \in \mathbb { R } ^ { 2 d + 1 } \mapsto H ( p , q , t ) \in \mathbb { R }$ through a system of ordinary differential equations called Hamilton’s equations,
+
+$$
+\dot { p } = - \frac { \partial H } { \partial q } \ , \qquad \dot { q } = + \frac { \partial H } { \partial p } \ ,
+$$
+
+where we use the dot notation to compactly represent derivatives with respect to the time variable $t$ . We are focusing in this work on Hamiltonians that are conservative,1 that is, they do not depend on the time variable $t$ , and separable,2 that is, they can be written as a
+
+sum $H ( p , q ) = K ( p ) + V ( q )$ . In this case, (1) becomes
+
+$$
+\dot { p } = - V ^ { \prime } ( q ) , \dot { q } = K ^ { \prime } ( p )
+$$
+
+With a proper choice of the $p$ and $q$ variables, the evolution of essentially all physical systems can be described with the Hamiltonian framework. In other words, Hamilton’s equations restrict the vast space of dynamical systems to the considerably smaller space of dynamical systems that are physically plausible.
+
+Therefore, instead of modeling the dynamics of a physical system with a neural network $f _ { \boldsymbol { \theta } } ( \boldsymbol { p } , \boldsymbol { q } )$ whose outputs are interpreted as estimates of the time derivatives $\dot { p }$ and $\dot { q }$ , we can also use a neural network $H _ { \boldsymbol \theta } ( p , q ) = K _ { \boldsymbol \theta _ { 1 } } ( p ) + V _ { \boldsymbol \theta _ { 2 } } ( q )$ with $\theta = \lfloor \theta _ { 1 } , \theta _ { 2 } \rfloor$ , whose partial derivatives $- V _ { \theta _ { 2 } } ^ { \prime } ( q )$ and $K _ { \theta _ { 1 } } ^ { \prime } ( p )$ are interpreted as the time derivatives $\dot { p }$ and $\dot { q }$ . We refer to the former as ODE neural networks (O-NET) and the latter approach as Hamiltonian neural networks (H-NET). In order to define a complete learning system, we need to explain how to determine the parameter $\theta$ of the neural networks on the basis of observed discrete trajectories. For instance, Greydanus et al. (2019) trains H-NET in a fully supervised manner using the observed tuples $( p , q , \dot { p } , \dot { q } )$ .
+
+# 3.2 From ODEs to discrete trajectories
+
+A numerical integrator (or ODE solver) approximates the true solution of an ODE of the form $\dot { z } = f ( z , t )$ at discrete time steps $t _ { 0 } , t _ { 1 } . . . t _ { T }$ . For instance, the simplest integrator, Euler’s integrator, starts from the initial state $z _ { \mathrm { 0 } }$ at time $t _ { 0 }$ and estimates the function $z ( t )$ at uniformly spaced time points $t _ { n } = t _ { 0 } + n \Delta t$ with the recursive expression
+
+$$
+z _ { n + 1 } = z _ { n } + \Delta t f ( z _ { n } , t _ { n } )
+$$
+
+In stiff ODE systems, however, using Euler’s method could easily lead to unstable solutions unless the time-step is chosen to be very small (Lambert, 1991). The development of efficient and accurate numerical integrators is the object of considerable research (Hairer et al., 2008; Hairer and Wanner, 2013). Symplectic integrators3 are particularly attractive for the integration of Hamilton’s equations (Leimkuhler and Reich, 2005). They are able to preserve quadratic invariants, and therefore usually have desired stability properties as well as being structure-preserving (McLachlan et al., 2004), even for certain non-Hamiltonian systems (Chen et al., 2018b). A simple and widely-used symplectic integrator is the leapfrog integrator. When the Hamiltonian is conservative and separable (2), it computes successive estimates $( p _ { n } , q _ { n } )$ with
+
+$$
+\begin{array} { r l } & { p _ { n + 1 / 2 } = p _ { n } - \frac { 1 } { 2 } \Delta t V ^ { \prime } ( q _ { n } ) } \\ & { ~ q _ { n + 1 } = q _ { n } + \Delta t K ^ { \prime } ( p _ { n + 1 / 2 } ) } \\ & { ~ p _ { n + 1 } = p _ { n + 1 / 2 } - \frac { 1 } { 2 } \Delta t V ^ { \prime } ( q _ { n + 1 } ) } \end{array}
+$$
+
+Repeatedly executing update equations (4) is called the leapfrog algorithm, which is as computationally efficient as Euler’s method yet considerably more accurate when the ODE belongs to a Hamiltonian system (Leimkuhler and Reich, 2005).
+
+# 3.3 Learning ODEs from discrete trajectories
+
+Following Chen et al. (2018a), let the right hand side of the ODE be a parametric function $f _ { \theta } ( z , t )$ and let $z _ { 0 } \dots z _ { T }$ be an observed trajectory measured at uniformly spaced time points $t _ { 0 } \ldots t _ { T }$ . We can estimate the parameter $\theta$ that best represents the dynamics of the observed trajectory by minimizing the mean squared error $\begin{array} { r } { \sum _ { i = 1 } ^ { T ^ { \prime } } \| z _ { i } - \hat { z } _ { i } ( \theta ) \| _ { 2 } } \end{array}$ between the observed trajectory $\{ z _ { i } \} _ { i = 0 } ^ { I }$ and the trajectory $\{ \hat { z } _ { i } ( \theta ) \} _ { i = 0 } ^ { T }$ generated with our integrator of choice,
+
+$$
+\{ \hat { z } _ { i } ( \theta ) \} _ { i = 0 } ^ { T } = I n t e g r a t o r ( z _ { 0 } , f _ { \theta } , \{ t _ { i } \} _ { i = 0 } ^ { T } ) ~ .
+$$
+
+For instance, this minimization can be achieved using stochastic gradient descent after back-propagating through the steps of our numerical integration algorithm of choice and then through each call to the functions $f _ { \theta }$ . This can be done when $f _ { \theta } ( z )$ is a neural network (O-NET), or is the concatenation $[ - V _ { \theta _ { 2 } } ^ { \prime } ( q ) , K _ { \theta _ { 1 } } ^ { \prime } ( p ) ]$ of the partial derivatives of an H-NET
+
+$H _ { \boldsymbol \theta } ( p , q ) = K _ { \boldsymbol \theta _ { 1 } } ( p ) + V _ { \boldsymbol \theta _ { 2 } } ( q )$ , where the partial derivatives can be expressed using the same parameters $\theta$ as the Hamiltonian $H _ { \theta } ( p , q )$ , for instance using automatic differentiation. We can then predict trajectories at testing time using the trained $f _ { \theta ^ { \ast } }$ and initial state $z _ { 0 } ^ { \mathrm { t e s t } }$ ,
+
+$$
+\left\{ \hat { z } _ { i } ^ { \mathrm { t e s t } } \right\} _ { i = 0 } ^ { T ^ { \mathrm { t e s t } } } = I n t e g r a t o r ( z _ { 0 } ^ { \mathrm { t e s t } } , f _ { \theta ^ { * } } , \left\{ t _ { i } \right\} _ { i = 0 } ^ { T ^ { \mathrm { t e s t } } } ) \ .
+$$
+
+Note that neither the integrator, nor the number of steps, nor the step size, need to be the same at training and testing.
+
+# 3.4 Symplectic Recurrent Neural Network
+
+This framework provides a number of nearly orthogonal design options for the construction of algorithms that model dynamical systems using trajectories:
+
+• The time derivative model could be an O-NET or H-NET. The training integrator can be any explicit integrators. In our experiments, we only focus on Euler’s integrator and the leapfrog integrator. The training trajectories can consist of a single step, $T { = } 1$ , or multiple steps, $T > 1$ . We refer to the first case as single-step and the second case as multi-step or recurrent training, because back-propagating through multiple steps of the training integrator is comparable to back-propagating through time in recurrent networks.   
+• The testing integrator can also be chosen freely and can use a different time-step size as it does not involve back-propagation.
+
+In order to save space while describing the possibly different integrators used for training and testing, we use the labels “E-E”, “E-L”, and “L-L”, where the first letter tells which integrator was used for training —“E” for Euler and “L” for leapfrog— and the second letter indicates which integrator was used as testing time. For instance, with our terminology, the HNN model of Greydanus et al. (2019) is a “single-step E-E H-NET” with the additional subtlety that they supervise the training with actual derivatives instead of relying on finite differences between successive steps of the observed trajectories.
+
+A Symplectic Recurrent Neural Network (SRNN) is a recurrent H-NET that relies on a symplectic integrator for both training and testing, such as, for instance, a "recurrent L-L H-NET". As shown in the rest of this paper, SRNNs are far more usable and robust than the alternatives, especially when the Hamiltonian gets complex and the data gets noisy. We believe that SRNNs may also have other potential benefits: because leapfrog preserves volumes in the state space (Hairer et al., 2002), we conjecture that vanishing and exploding gradients’ issues in backpropagating through entire state sequences are ameliorated (Arjovsky et al., 2015). Finally, because the leapfrog integrator is reversible in time, there is no need to store states during the forward pass as they can be recomputed exactly during the backward pass. We leave studying these other computational and optimization benefits as a topic of future work.
+
+# 4 SRNN can learn complex and noisy Hamiltonian dynamics
+
+As an example of a complex Hamiltonian system, we first present experiments performed on the spring-chain system: a chain of 20 masses with neighbors connected via springs. Each of the two masses on the ends are connected to fixed ground via another spring. The chain can be assumed to lay horizontally and the masses move vertically but no gravity is assumed. The 20 masses and the 21 spring constants are chosen randomly and independently. The training data consist of 1000 trajectories of the same chain, each of which starts from a random initial state of positions and momenta of the masses and is 10-time-step long (including the initial state). We thus take $T = 9$ when performing recurrent training. When performing single-step training, each training trajectory of length 10 is instead considered as 9 consecutive trajectories of length 2. In this way, 1000 sample trajectories of length 10 ( $T$ =9) are turned into 9000 sample trajectories of length 2 ( $T { = } 1$ ), allowing for a fair comparison between single-step training and recurrent training. During testing, the trained model is given 32 random initial states in order to predict 32 trajectories of length 100. Detailed experiment setups and model architectures are provided in Appendix A.1, and a PyTorch implementation can be found at https://github.com/zhengdao-chen/SRNN.git.
+
+![](images/9b538b538f589912be7bd4e31d61df851eaba2304128f8d044ea9a3e9b6b14d1.jpg)  
+Figure 1: Testing results in the noiseless case by single-step methods. Left: Prediction error of each method over time, measured by the L2 distance between the true and predicted positions of the 20 masses. Right: Each curve represents the position of one of the masses (number 5) as a function of time predicted by the three single-step-trained H-NET models. Plots of the other masses’ positions are provided in Appendix D.1.
+
+# 4.1 Going symplectic - rescuing HNN with the leapfrog integrator
+
+First, we consider the noiseless case, where the training data consist of exact values of the positions $( q )$ and momenta (p) of the masses on the chain at each discrete time point. As shown in figure 1, the prediction of a single-step E-E H-NET deviates from the ground truth quickly and is unable to capture the periodic motion. By comparison, a single-step E-E ONET yields predictions that is qualitatively reasonable. This shows that using Hamiltonian models without paying attention to the integration scheme may not be a good idea.
+
+We then replace Euler’s integrator used during testing by a leapfrog integrator, yielding a Single-step E-L H-NET. Figure 1 shows that this helps the H-NET produce predictions that remain stable and periodic over a longer period of time. Since the training process remains the same, this implies that part of the instability and degeneration of H-NET’s predictions comes from the nature of Euler’s integrator rather than the lack of proper training.
+
+In contrast, using a leapfrog integrator for both training and testing substantially improve the performance, as also shown again in figure 1. This improvement shows the importance of consistency between the integrators used in training and predicting modes. This can be understood with the concept of modified equations (Hairer, 1994): when we use a numerical integrator to solve an ODE, the numerical solution usually does not strictly follow the original equation due to discretization, but can be regarded as a solution to a modified version of the original equation that depends on the integrator and the time-step size. Therefore, training and testing with the same numerical integrator and time-step size could allow the system to learn a modified Hamiltonian that corrects some of the errors caused by the discretization scheme.
+
+# 4.2 Going recurrent - using multi-step training when noise is present
+
+Since noise is prevalent in real-world observations, we also test our models on noisy trajectories. Independent and identically distributed Gaussian noise is added to both the position and the momentum variables at each time step. Applying the single-step methods described above yield considerably worse predictions, as shown in Figure 2 (left).
+
+This phenomenon can be controlled by training on multiple steps, effectively arriving at a type of recurrent neural network: if noise is added independently at each time-step, then having data from multiple consecutive time steps may allow us to discern the actual noiseless trajectory, analogous to performing linear regression on multiple (more than 2) noisy data points. As we see in Figure 2 (left), recurrent training consistently improves the predictions except for E-E H-NET. The best performing model is the SRNN (recurrent L-L H-Net) which improves substantially over the single-step L-L H-NET. Interestingly, the recurrent E-E H-NET does not improve over the single-step E-E H-NET, which means that recurrent training does not help if one uses a naïve integrator.
+
+# 4.3 Initial state optimization (ISO)
+
+However, one issue remains to be addressed: in the framework that we have adopted so far, the initial states $p _ { 0 }$ and $q _ { 0 }$ are treated as the actual initial states from which the system begins to evolve despite the added noise in observation. With noise added to the observation of $p _ { 0 }$ and $q _ { 0 }$ , our dynamical models will start from these noisy states and remain biased as we advance in time in both the training and the testing mode.
+
+![](images/eee0d8f6c04f4bfdbfb00b4d5eeb875bdcd1f04d436115517315983e6d9cad88.jpg)  
+Figure 2: Prediction error of all methods in the noisy case measured by L2 distance, presented in two plots due to the large number of methods. Included in the left plot are the single-step-trained methods, recurrently trained methods, vanilla RNN and LSTM. Included in the right plot are the (same) recurrently trained methods, the recurrently trained methods with initial state optimization (ISO), as well as vanilla RNN and LSTM with ISO.
+
+![](images/30befd7f3e22c1057a74b4852ef1e47cad7607a2e215fa16b4a2ed2f0248acd7.jpg)  
+Figure 3: Predictions made by three methods in the noisy case. The Y-axis corresponds to the position of one of the masses (number 5) on the chain.
+
+To mitigate this issue, we propose to introduce two new parameter vectors for each sample, $\hat { p } _ { 0 }$ and $\hat { q } _ { 0 }$ , interpreted as our estimate of the actual initial states, and we let our dynamical models evolve starting from them instead of the observed $p _ { 0 }$ and $q _ { 0 }$ . Treating $\hat { p } _ { 0 }$ and $\hat { q } _ { 0 }$ as parameters, we can optimize them based on the loss function while fixing the model’s parameters, a process that we call initial state optimization (ISO). When the model is good enough, we hope that this will guide us towards the true initial states without observation noise. In Appendix B, we motivate the use of ISO from the perspective of maximum likelihood inference. In actual training, we first train the neural network parameters for 100 epochs as usual, and starting from the 101st, after every epoch we perform ISO with the L-BFGS-B algorithm (Zhu et al., 1997) on the $\hat { p } _ { 0 }$ and $\hat { q } _ { 0 }$ parameters for every training trajectory. At testing time, the model is given the noisy values of $p$ and $q$ for the first 10 time steps and must complete the trajectory for the next 200 steps. These 10 initial time steps allow us to perform the same L-BFGS-B optimization to determine the initial state $\hat { p } _ { 0 }$ before advancing in time to predict the entire trajectory.
+
+As seen in Figure 2 (right), SRNN-ISO (i.e. SRNN equipped with ISO) clearly yields the best prediction among all the methods. Figure 3 shows the predictions of HNN, SRNN and SRNN-ISO on one test sample, and we clearly see the qualitative improvements thanks to recurrent training and ISO. O-NET also benefits from ISO while vanilla RNN and LSTM do not seem to, likely because the initial state optimization only works when we already have a reasonable model of the system. In Appendix C, we give a heuristic argument for the convexity of ISO, which helps to explain the success of using L-BFGS-B for ISO.
+
+In summary, we have proposed three extensions to learning complex and noisy dynamics with H-NET and demonstrated the improvements they lead to: a) using the leapfrog integrator instead of Euler’s integrator; b) using recurrent instead of single-step training; and c)
+
+Table 1: Testing results of predicting the dynamics of the spring-chain system by methods based on fixed $p _ { 0 }$ , $q _ { 0 }$ (i.e., not optimizing $p _ { 0 }$ , $q _ { 0 }$ as parameters). The error is defined as the discrepancy between the (noisy) ground truth and the predictions at each time step averaged over the first 200 time steps, where the discrepancy is measured by the L2 distance between the true and predicted positions of the 20 masses in the chain, both of which considered as 20-dimensional vectors. The mean and standard deviation are computed based on 32 testing samples, each starting from a random configuration of the chain.
+
+Table 2: Testing results of predicting the dynamics of the spring-chain system by methods that optimize on $p _ { 0 }$ and $q _ { 0 }$ starting from their observed (noisy) values using L-BFGS-B, as explained in the text. The definition of the errors is the same as in the above table.   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Integrator (tr)</td><td rowspan=1 colspan=1>Integrator(te)</td><td rowspan=1 colspan=1>Error mean</td><td rowspan=1 colspan=1>Error std</td></tr><tr><td rowspan=6 colspan=1>single-step</td><td rowspan=3 colspan=1>O-NET</td><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>6.93</td><td rowspan=1 colspan=1>1.22</td></tr><tr><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>5.87</td><td rowspan=1 colspan=1>1.04</td></tr><tr><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>7.28</td><td rowspan=1 colspan=1>1.48</td></tr><tr><td rowspan=3 colspan=1>H-NET</td><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>7.24</td><td rowspan=1 colspan=1>0.64</td></tr><tr><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>3.32</td><td rowspan=1 colspan=1>0.89</td></tr><tr><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>3.36</td><td rowspan=1 colspan=1>0.67</td></tr><tr><td rowspan=8 colspan=1>recurrent</td><td rowspan=3 colspan=1>O-NET</td><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>2.88</td><td rowspan=1 colspan=1>0.45</td></tr><tr><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>4.12</td><td rowspan=1 colspan=1>0.41</td></tr><tr><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>3.34</td><td rowspan=1 colspan=1>0.86</td></tr><tr><td rowspan=3 colspan=1>H-NET</td><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>7.58</td><td rowspan=1 colspan=1>0.63</td></tr><tr><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>5.26</td><td rowspan=1 colspan=1>0.63</td></tr><tr><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>2.37</td><td rowspan=1 colspan=1>0.87</td></tr><tr><td rowspan=1 colspan=1>Vanilla RNN</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>4.80</td><td rowspan=1 colspan=1>0.82</td></tr><tr><td rowspan=1 colspan=1>LSTM</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>5.95</td><td rowspan=1 colspan=1>1.05</td></tr></table>
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Integrator (tr)</td><td rowspan=1 colspan=1>Integrator (te)</td><td rowspan=1 colspan=1>Error mean</td><td rowspan=1 colspan=1>Error std</td></tr><tr><td rowspan=3 colspan=1>O-NET</td><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>2.13</td><td rowspan=1 colspan=1>0.37</td></tr><tr><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>3.59</td><td rowspan=1 colspan=1>0.50</td></tr><tr><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>2.27</td><td rowspan=1 colspan=1>0.60</td></tr><tr><td rowspan=3 colspan=1>H-NET</td><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>6.26</td><td rowspan=1 colspan=1>0.60</td></tr><tr><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>3.00</td><td rowspan=1 colspan=1>0.63</td></tr><tr><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>1.45</td><td rowspan=1 colspan=1>0.32</td></tr><tr><td rowspan=1 colspan=1>Vanilla RNN</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>4.72</td><td rowspan=1 colspan=1>0.94</td></tr><tr><td rowspan=1 colspan=1>LSTM</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>5.81</td><td rowspan=1 colspan=1>0.98</td></tr></table>
+
+optimizing the initial states of each trajectory as parameters when data are noisy. Thorough comparisons of test errors are given in Tables 1 and 2, where we highlight that the SRNN (recurrent L-L H-NET) models achieve the lowest errors.
+
+# 5 SRNN can learn the dynamics of a three-body system
+
+Next, we test SRNN with the three-body system, which is a well-known example of a chaotic system, meaning that a small difference in the initial condition could lead to drastically different evolution trajectories, even without noise added. As a result, even when the exact equations are known, simulating it with different time-step sizes could also lead to qualitatively different solutions. Moreover, Greydanus et al. (2019) mentions that HNN does not outperform a baseline method using O-NET in learning the three-body system’s evolution. Here, we test our SRNN together with other baselines on the noiseless three-body system with the same configurations as Greydanus et al. (2019). The detailed experimental setup and model architectures are provided in Appendix A.2.
+
+As we see in Table 3, the best-performing model is SRNN and the second-best is the singlestep L-L H-NET. Interestingly, and perhaps counter-intuitively, they even outperform the baseline method of simulating the correct equation with the same time-step size. How is this possible? In short, our explanation is that the error introduced by numerical discretization could be learned and therefore compensated for by the models we train. More concretely, once again using the concept of modified equations mentioned in Section 4.1, we argue that the ODE-based learning models, including both H-NET and O-NET models, could learn not
+
+Table 3: Prediction error results for the three-body system with time-step $\Delta t = 1$ . The last row corresponds to numerically solving the correct underlying equations using the leapfrog integrator with time-step $\Delta t = 1$ . The other rows correspond to the different learning-based methods, same as in the spring-chain experiments.
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Integrator (tr)</td><td rowspan=1 colspan=1>Integrator (te)</td><td rowspan=1 colspan=1>Error mean</td><td rowspan=1 colspan=1>Error std</td></tr><tr><td rowspan=6 colspan=1>single-step</td><td rowspan=3 colspan=1>O-NET</td><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>0.65</td><td rowspan=1 colspan=1>0.16</td></tr><tr><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>1.36</td><td rowspan=1 colspan=1>0.18</td></tr><tr><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>1.33</td><td rowspan=1 colspan=1>0.20</td></tr><tr><td rowspan=3 colspan=1>H-NET</td><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>1.64</td><td rowspan=1 colspan=1>0.25</td></tr><tr><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>0.88</td><td rowspan=1 colspan=1>0.33</td></tr><tr><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>0.35</td><td rowspan=1 colspan=1>0.09</td></tr><tr><td rowspan=6 colspan=1>recurrent</td><td rowspan=3 colspan=1>O-NET</td><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>0.51</td><td rowspan=1 colspan=1>0.11</td></tr><tr><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>1.27</td><td rowspan=1 colspan=1>0.18</td></tr><tr><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>0.49</td><td rowspan=1 colspan=1>0.10</td></tr><tr><td rowspan=3 colspan=1>H-NET</td><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>0.79</td><td rowspan=1 colspan=1>0.17</td></tr><tr><td rowspan=1 colspan=1>Euler</td><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>1.76</td><td rowspan=1 colspan=1>0.62</td></tr><tr><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>0.26</td><td rowspan=1 colspan=1>0.07</td></tr><tr><td rowspan=1 colspan=1>simulation</td><td rowspan=1 colspan=1>true eqns.</td><td rowspan=1 colspan=1>(no training)</td><td rowspan=1 colspan=1>Leapfrog</td><td rowspan=1 colspan=1>0.47</td><td rowspan=1 colspan=1>0.18</td></tr></table>
+
+the correct underlying equation, but rather the equation whose modified equation associated with our choice of numerical integrator and time-step size is the original equation. Hence, when the time-step size is large and the error of numerical discretization is not negligible, it is possible that the learned equation could yield better predictions than the correct one.
+
+In addition, we also see that the recurrently trained models outperform the corresponding single-step-trained models. Plots of the predicted trajectories are provided in Appendix E.
+
+# 6 Learning perfect rebound with an augmented SRNN
+
+We focus in this section on the perfect rebound problem as a prototypical example of stiff ODE in a physical system. We consider a heavy billiard, subject to gravitational forces pointing downwards, and bouncing around a two-dimensional square domain delimited by impenetrable walls. Whenever it hits a wall, the billiard rebounds without loss of energy, by reversing the component of its momentum orthogonal to the wall surface. Microscopically, when the billiard hits the wall, the atomic structure deformation produces strong electromagnetic forces that reverse the momentum during a very brief timescale. Simulating this microscopic phenomenon with a Hamiltonian ODE would not only be computationally expensive, but also require a detailed knowledge of the atomic structures of the billiard and the walls. The perfect rebound is a macroscopic approximation that treats the billiard as a point mass and the rebound as an event with zero duration infinite forces. Although this approximation is convenient for high-school level derivations, the singularity makes it hard to simulate using Hamiltonian dynamics.
+
+We propose to approach this problem by augmenting each time step of a leapfrog-based SRNN with an additional operation that models a possible rebound event,
+
+$$
+p _ { t } ^ { p o s t }  p _ { t } ^ { p r e } - 2 ( p _ { t } ^ { p r e } \cdot n ) n ~ ,
+$$
+
+where $p _ { t } ^ { p r e }$ is the pre-rebound momentum vector and $p _ { t } ^ { p o s t }$ is the post-rebound momentum vector. When the vector $n$ is zero, this operation does not change the momentum in any way. When $n$ is a unit vector orthogonal to a wall, this operation computes the momentum reversal that is characteristic of a perfect rebound. Vectors $n$ of smaller length could also be used to model energy dissipation in manner that is reminiscent of the famous LSTM forget gate (Hochreiter and Schmidhuber, 1997).
+
+Because the billiard trajectory depends on the exact timing of the rebound event, we also need a scalar $\alpha \in \lfloor 0 , 1 \rfloor$ that precisely places the rebound event at time $t + \alpha \Delta t$ between the successive time steps $t$ and $t + \Delta t$ . The augmented leapfrog schema then becomes
+
+$$
+[ p _ { t + \alpha \Delta t } ^ { p r e } , q _ { t + \alpha \Delta t } ^ { p r e } ] \gets \{ \frac { l e a p f r o g } { \alpha \Delta t } \left[ p _ { t } , q _ { t } \right]
+$$
+
+$$
+p _ { t + \alpha \Delta t } ^ { p o s t } = p _ { t + \alpha \Delta t } ^ { p r e } - 2 ( p _ { t + \alpha \Delta t } ^ { p r e } \cdot n ) n
+$$
+
+![](images/83b5660a973c4dc436d8959be4cf1868b47997b26d7f9f5e681925629384c6b3.jpg)  
+Figure 4: Actual versus predicted trajectories of the heavy billiard with perfect rebound. The predictions are obtained by an SRNN plus the rebound module described in section 6.
+
+$$
+\left[ p _ { t + \Delta t } , q _ { t + \Delta t } \right] \underset { ( 1 - \alpha ) \Delta t } { \xleftarrow { l e a p f r o g } } \left[ p _ { t + \alpha \Delta t } ^ { p o s t } , q _ { t + \alpha \Delta t } ^ { p o s t } \right]
+$$
+
+where equations (6) and (8) represent ordinary leapfrog updates (4) for time steps of respective durations $\alpha \Delta t$ and $( 1 - \alpha ) \Delta t$ . More precisely, we first compute a tentative position $\ddot { q } _ { t + \Delta t }$ and momentum $\tilde { p } _ { t + \Delta t }$ assuming no rebound,
+
+$$
+\left[ \tilde { p } _ { t + \Delta t } , \tilde { q } _ { t + \alpha \Delta t } \right] \underbrace { l e a p f r o g } _ { \Delta t } \left[ p _ { t } , q _ { t } \right] ,
+$$
+
+then compute both $n$ and $\alpha$ as parametric functions of the tentative position $\tilde { q } _ { t + \Delta t }$ as well as the current position $q _ { t }$ , and finally apply the forward model (6–8). Note that the final state is equal to the tentative state when no rebound occurs, that is, when $n = 0$ .
+
+Directly modeling $n$ and $\alpha$ with a neural network taking $\ddot { q } _ { t + \Delta t }$ as the input would be very inefficient because we would need to train with a lot of rebound events to precisely reveal the location of the walls. We chose instead to use visual cues in the form of a background image representing the walls. We model $n$ as the product of a direction vector $n$ and a magnitude $\gamma \in \left[ 0 , 1 \right]$ , and we want the latter to take value close to 1 when perfect rebound actually occurs between $t$ and $t + \Delta t$ and close to 0 otherwise. Both $n$ and $\alpha$ are modeled as MLPs that take as input two 10x10 neighborhoods of the background image, centered at positions $q _ { t }$ and $\ddot { q } _ { t + \Delta t }$ , respectively. In contrast, $\gamma$ is modeled as an MLP that takes as input a smaller $2 \mathrm { x } 2$ neighborhood centered at $\tilde { q } _ { t + \Delta t }$ and is trained with an additional regularization term $\| \gamma \| _ { 1 }$ in order to switch the rebound module off when it is not needed.
+
+Training is achieved by back-propagating through the successive copies of the augmented leapfrog scheme, through the models of $n$ , $\alpha$ , and $\gamma$ , and also through the computation of the tentative $\ddot { p } _ { t + \Delta t }$ and $\ddot { q } _ { t + \Delta t }$ . We use 5000 training trajectories of length 10 starting from a randomly-sampled initial positions and velocities. Similarly, we use 32 testing trajectories of length 60. Detailed exprimental setup is included in Appendix A.3. Figure 5 plots some predicted and actual testing trajectories. Appendix F compares these results with the inferior results obtained with several baseline methods, including SRNN without the rebound module, and SRNN with a rebound module that does not learn $\alpha$ . One limitation of our method, however, results from the assumption that there is at most one rebound event per time step. Although this assumption fails when the billiard rebounds twice near a corner, as shown in the bottom right plot in Figure 5, our method still outperforms the baseline methods even in this case.
+
+# 7 Conclusion
+
+We propose the Symplectic Recurrent Neural Network, which learns the dynamics of Hamiltonian systems from data. Thanks to symplectic integration, multi-step training and initial state optimization, it outperforms previous methods in predicting the evolution of complex and noisy Hamiltonian systems, such as the spring-chain and the three-body systems. It can even outperform simulating with the exact equations, likely by learning to compensate for numerical discretization error. We further augment it to learn perfect rebound from data, opening up the possibility to handle stiff systems using ODE-based learning algorithms.
+
+# Acknowledgments
+
+The authors acknowledge stimulating discussions with Dan Roberts, Marylou Gabrié, Anna Klimovskaia, Yann Ollivier and Joan Bruna.
+
+# References
+
+Arjovsky, M., Shah, A., and Bengio, Y. (2015). Unitary evolution recurrent neural networks. CoRR, abs/1511.06464.
+
+Battaglia, P. W., Pascanu, R., Lai, M., Rezende, D. J., and Kavukcuoglu, K. (2016). Interaction networks for learning about objects, relations and physics. CoRR, abs/1612.00222.
+
+Brunton, S. L., Proctor, J. L., and Kutz, J. N. (2016). Discovering governing equations from data by sparse identification of nonlinear dynamical systems. Proceedings of the National Academy of Sciences, 113(15):3932–3937.
+
+Chang, B., Chen, M., Haber, E., and Chi, E. H. (2019). AntisymmetricRNN: A dynamical system view on recurrent neural networks. In International Conference on Learning Representations.
+
+Chang, M. B., Ullman, T., Torralba, A., and Tenenbaum, J. B. (2016). A compositional object-based approach to learning physical dynamics. CoRR, abs/1612.00341.
+
+Chen, T. Q., Rubanova, Y., Bettencourt, J., and Duvenaud, D. K. (2018a). Neural ordinary differential equations. In Bengio, S., Wallach, H., Larochelle, H., Grauman, K., CesaBianchi, N., and Garnett, R., editors, Advances in Neural Information Processing Systems 31, pages 6571–6583. Curran Associates, Inc.
+
+Chen, Z., Raman, B., and Stern, A. (2018b). Structure-preserving numerical integrators for hodgkin-huxley-type systems.
+
+Greydanus, S., Dzamba, M., and Yosinski, J. (2019). Hamiltonian neural networks. arXiv preprint arXiv:1906.01563.
+
+Hairer, E. (1994). Backward analysis of numerical integrators and symplectic methods. Annals of Numerical Mathematics, 1:107–132. ID: unige:12640.
+
+Hairer, E., Lubich, C., and Wanner, G. (2002). Geometric Numerical Integration: StructurePreserving Algorithms for Ordinary Differential Equations. Springer series in computational mathematics. Springer.
+
+Hairer, E., Nørsett, S. P., and Wanner, G. (2008). Solving Ordinary Differential Equations I: Nonstiff Problems. Springer Series in Computational Mathematics. Springer Berlin Heidelberg.
+
+Hairer, E. and Wanner, G. (2013). Solving Ordinary Differential Equations II: Stiff and Differential - Algebraic Problems. Springer Series in Computational Mathematics. Springer Berlin Heidelberg.
+
+Hochreiter, S. and Schmidhuber, J. (1997). Long short-term memory. Neural Computation, 9(8):1735–1780.
+
+Kingma, D. P. and Ba, J. (2014). Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980.
+
+Lambert, J. D. (1991). Numerical Methods for Ordinary Differential Systems: The Initial Value Problem. John Wiley & Sons, Inc., New York, NY, USA.   
+Leimkuhler, B. and Reich, S. (2005). Simulating Hamiltonian Dynamics. Cambridge Monographs on Applied and Computational Mathematics. Cambridge University Press.   
+Lutter, M., Ritter, C., and Peters, J. (2019). Deep lagrangian networks: Using physics as model prior for deep learning. In International Conference on Learning Representations.   
+McLachlan, R. I., Perlmutter, M., and Quispel, G. R. W. (2004). On the nonlinear stability of symplectic integrators. BIT Numerical Mathematics, 44(1):99–117.   
+Niu, M. Y., Horesh, L., and Chuang, I. (2019). Recurrent neural networks in the eye of differential equations. arXiv preprint arXiv:1904.12933.   
+Peifer, M. and Timmer, J. (2007). Parameter estimation in ordinary differential equations for biochemical processes using the method of multiple shooting. The Institution of Engineering and Technology, Systems Biology.   
+Stapor, P., Fröhlich, F., and Hasenauer, J. (2018). Optimization and profile calculation of ODE models using second order adjoint sensitivity analysis. Bioinformatics, 34(13):i151– i159.   
+Tao, M. (2016). Explicit symplectic approximation of nonseparable hamiltonians: Algorithm and long time performance. Phys. Rev. E, 94:043303.   
+Zhu, C., Byrd, R. H., Lu, P., and Nocedal, J. (1997). Algorithm 778: L-bfgs-b: Fortran subroutines for large-scale bound-constrained optimization. ACM Trans. Math. Softw., 23(4):550–560.
+
+# A Experiment setup
+
+# A.1 The spring-chain experiment
+
+We set $\Delta t = 0 . 1$ . The ground truth trajectories in both training and testing are simulated by the leapfrog integrator using $\Delta t ^ { \prime } = 0 . 0 0 1$ and coarsened into time-grids of 0.1 with a factor of 100, since simulating with a much smaller time-step leads to much more accurate solution, which we will treat as the ground truth solution.
+
+The O-NET that represents $f _ { \theta } ( p , q )$ is a one-hidden-layer MLP with 40 input units, 2048 hidden units and 40 output units. The H-NET that represents $H _ { \boldsymbol \theta } ( p , q ) = K _ { \boldsymbol \theta _ { 1 } } ( p ) + V _ { \boldsymbol \theta _ { 2 } } ( q )$ consists of two one-hidden-layer MLPs, one for $K _ { \theta _ { 1 } }$ and the other for $V _ { \theta _ { 2 } }$ . Each of the MLPs have 20 input units, 2048 hidden units and 1 output unit. The vanilla RNN and LSTM models also have hidden states of size 2048. Implemented in PyTorch, the models are trained over 1000 epochs with the Adam optimizer (Kingma and Ba, 2014) with initial learning rate 0.001 and using the ReduceLROnPlateau scheduler $^ 4$ with patience 15 and factor 0.7.
+
+# A.2 The three-body experiment
+
+The ground truth trajectories are simulated by SciPy’s solve_ivp adaptive solver $^ { 5 }$ with method RK45. We coarse-grain the simulated ground truth trajectories into time-steps of $\Delta t = 1$ , so that the models developed in section 4 are numerically integrated with time-step $\Delta t = 1$ in both training and testing. We intentionally set the time-step to be relatively large, so that it becomes interesting to compare these models with a baseline method of simulating the true equations with time-step $\Delta t = 1$ . In addition, the training data consist of 100 sample trajectories of length 10 $\cdot \Delta t = 1 0$ , which are then turned into 900 trajectories of length 2 and 600 trajectories of length 5, respectively for single-step and recurrent training, in the same way as for the spring-chain experiments above.
+
+The O-NET that represents $f _ { \boldsymbol { \theta } } ( \boldsymbol { p } , \boldsymbol { q } )$ is a three-hidden-layer MLP with 12 input units, 512 hidden units in each hidden layer and 12 output units. The H-NET that represents $H _ { \boldsymbol \theta } ( p , q ) = K _ { \boldsymbol \theta _ { 1 } } ( p ) + V _ { \boldsymbol \theta _ { 2 } } ( q )$ consists of two three-hidden-layer MLPs, one for $K _ { \theta _ { 1 } }$ and the other for $V _ { \theta _ { 2 } }$ . Each of the MLPs have 6 input units, 512 hidden units in each hidden layer and 1 output unit. The vanilla RNN and LSTM models also have hidden states of size 512. Implemented in PyTorch, the models are trained over 1000 epochs with the Adam optimizer with initial learning rate 0.0003 and using the ReduceLROnPlateau scheduler with patience 15 and factor 0.7.
+
+# A.3 The heavy billiard experiment
+
+The full image has size 128x128 pixels. The thickness of the wall is 12 pixels on each of the four sides, which leaves the free space of size 104x104 pixels in the middle for the billiard to move within. The billiard has size 3x3 pixels.
+
+The O-NET that represents $f _ { \boldsymbol { \theta } } ( \boldsymbol { p } , \boldsymbol { q } )$ is a one-hidden-layer MLP with 4 input units, 32 hidden units and 4 output units. The H-NET that represents $H _ { \boldsymbol \theta } ( p , q ) = K _ { \boldsymbol \theta _ { 1 } } ( p ) + V _ { \boldsymbol \theta _ { 2 } } ( q )$ consists of two one-hidden-layer MLPs, one for $K _ { \theta _ { 1 } }$ and the other for $V _ { \theta _ { 2 } }$ . Each of the MLPs have 2 input units, 32 hidden units and 1 output unit. The vanilla RNN model also has hidden states of size 32. For the rebound module, $n$ is computed as the normalized output of a two-hidden-layer MLP, with 200 input units, 128 units in the first hidden layer, 32 units in the second hidden layer and 2 output units. $\alpha$ is also computed using a two-hiddenlayer MLP, sharing the first hidden layer units with the MLP for $n$ , and having 32 units in the second hidden layer and 1 output unit. $\gamma$ is computed by passing through sigmoid the output of a two-hidden-layer MLP, with 4 input units, 16 units in each hidden layer and 1 output unit. All of the activation functions are tanh except for the hidden-to-output activation in the MLP for $\alpha$ , where ReLU is used. Implemented in PyTorch, the models are trained over 1500 epochs with the Adam optimizer with initial learning rate 0.005 and using the ExponentialLR scheduler6 with decay factor 0.99 until the learning rate reaches 0.0001. We set $\Delta t = 0 . 1$ , and use 5000 trajectories of length $1 0 \cdot \Delta t = 1$ as training data, and 32 trajectories of length $6 0 \cdot \Delta t = 6$ as testing data.
+
+# B The Maximum Likelihood Estimation perspective
+
+In the presence of noise, we can interpret the learning problem described in section 3.3 above from the perspective of maximum likelihood inference, which also provides justification for treating the initial states as trainable parameters. We define models as follow:
+
+$$
+\begin{array} { c } { { \hat { z } _ { i } ( \theta ) = I n t e g r a t o r ( \hat { z } _ { 0 } = z _ { 0 } , f _ { \theta } , \{ t _ { i } \} _ { i = 0 } ^ { T } ) } } \\ { { q ( z _ { i } ; \theta ) = \displaystyle \frac { 1 } { \sqrt { ( 2 \pi ) ^ { d } \sigma ^ { 2 d } } } e ^ { - \| z _ { i } - \hat { z } _ { i } ( \theta ) \| _ { 2 } ^ { 2 } / ( 2 \sigma ^ { 2 } ) } } } \\ { { P ( \{ z _ { i } \} _ { i = 1 } ^ { n } | \theta ) = \displaystyle \prod _ { i = 1 } ^ { n } q ( z _ { i } ; \theta ) = \displaystyle \frac { 1 } { ( \sqrt { 2 \pi \sigma ^ { 2 } } ) ^ { n d } } \displaystyle \prod _ { i = 1 } ^ { n } e ^ { - \| z _ { i } - \hat { z } _ { i } ( \theta ) \| _ { 2 } ^ { 2 } / ( 2 \sigma ^ { 2 } ) } , } } \end{array}
+$$
+
+and $\mathcal { L } ( \boldsymbol { \theta } | \{ z _ { i } \} _ { i = 1 } ^ { n } ) = P ( \{ z _ { i } \} _ { i = 1 } ^ { n } | \boldsymbol { \theta } )$ is the likelihood function given the time-series data $\{ z _ { i } \} _ { i = 1 } ^ { n }$ Note that this model assumes independence between $z _ { i }$ and $z _ { j }$ for $i \neq j$ once $\theta$ is fixed.
+
+If we are to perform maximum likelihood inference, we arrive at the following:
+
+$$
+\operatorname* { m a x } _ { \theta } : \ \log \mathcal { L } ( \theta | \{ z _ { i } \} _ { i = 1 } ^ { n } ) = - \frac { n d } 2 \log \bigl ( 2 \pi \sigma ^ { 2 } \bigr ) - \frac { 1 } { 2 \sigma ^ { 2 } } \sum _ { i = 1 } ^ { n } \| z _ { i } - \hat { z } _ { i } ( \theta ) \| _ { 2 } ^ { 2 } ,
+$$
+
+which is equivalent to
+
+$$
+\operatorname* { m i n } _ { \theta } \ \sum _ { i = 1 } ^ { n } \| z _ { i } - \hat { z } _ { i } ( \theta ) \| _ { 2 } ^ { 2 }
+$$
+
+This provides a motivation for using the $L ^ { 2 }$ loss, as we did in the experiments.
+
+So far, we consider $\theta$ as the only parameter of the model defined by equations 10, and therefore the only argument of the likelihood function, while $\hat { z } _ { 0 }$ is fixed to be the observed initial state $z _ { 0 }$ . As a generalization, we can consider a strictly larger family of models by allowing $z _ { 0 }$ to vary as well. In this way, we treat both $\theta$ and $z _ { 0 }$ as the parameters in the model and therefore arguments of the likelihood function that we optimize on. In other words, the model becomes
+
+$$
+\begin{array} { l } { \displaystyle \hat { z } _ { i } ( \theta , \hat { z } _ { 0 } ) = { I n t e g r a t o r ( \hat { z } _ { 0 } , f _ { \theta } , \{ t _ { i } \} _ { i = 0 } ^ { T } ) } } \\ { \displaystyle q ( z _ { i } ; \theta , \hat { z } _ { 0 } ) = \frac { 1 } { \sqrt { ( 2 \pi ) ^ { d } \sigma ^ { 2 d } } } e ^ { - { \| z _ { i } - \hat { z } _ { i } ( \theta , \hat { z } _ { 0 } ) \| _ { 2 } ^ { 2 } } / { ( 2 \sigma ^ { 2 } ) } } } \\ { \displaystyle P ( \{ z _ { i } \} _ { i = 1 } ^ { n } | \theta , \hat { z } _ { 0 } ) = \prod _ { i = 1 } ^ { n } q ( z _ { i } ; \theta ) = \frac { 1 } { ( \sqrt { 2 \pi \sigma ^ { 2 } } ) ^ { n d } } \prod _ { i = 1 } ^ { n } e ^ { - { \| z _ { i } - \hat { z } _ { i } ( \theta ) \| _ { 2 } ^ { 2 } } / { ( 2 \sigma ^ { 2 } ) } } , } \end{array}
+$$
+
+and the optimization problem becomes
+
+$$
+\operatorname* { m i n } _ { \theta , \hat { z } _ { 0 } } ~ \sum _ { i = 1 } ^ { n } \| z _ { i } - \hat { z } _ { i } ( \theta , \hat { z } _ { 0 } ) \| _ { 2 } ^ { 2 } ,
+$$
+
+which justifies optimizing over the initial states $p _ { 0 }$ , $q _ { 0 }$ in addition to the neural network parameters $\theta$ as described in the previous section.
+
+Such an interpretation is similar to approaches for parameter estimation in the literature of inverse problems and systems biology, though in those cases the parameters of interest appear directly in ODEs instead of via neural networks (Peifer and Timmer, 2007; Stapor et al., 2018). In particular, jointly optimizing the parameters in the model as well as the initial value is called the initial value approach. However, despite the success we demonstrate in section 4.2, two difficulties of this approach have been pointed out: 1) The optimization could converge to local minima; 2) The numerical solution of the ODE can be unstable (Peifer and Timmer, 2007). As explained in section 4.1, using HNN together with the leapfrog integrator mitigates the second issue. But what about the first issue? In particular, even if we assume that the optimization of the neural network can work “magically” well and do not suffer from bag local minima, what about optimizing the initial value $\hat { z } _ { 0 }$ ?
+
+# C Symplecticness and initial-state-optimization convexity
+
+The success of optimizing on the initial state of the system in addition to the recurrent H-NET and O-NET models as described in section 4.2 raises the following question: If we already have a relatively well-trained H-NET or O-NET, is the optimization on the initial values convex? We formalize the question below and provide a heuristic answer.
+
+$f$ or sin $\begin{array} { r } { \frac { d z } { d t } = f ( z ) } \end{array}$ we restrict our attendoes not depend on $t$ on to autonomous ODEs, which means that the function. Assuming existence and uniqueness of solutions, there exists a function that maps each initial state from $\hat { z } _ { 0 }$ for time $t$ , $\phi _ { t } ( \hat { z } _ { 0 } )$ . This function is usually called the flow map. Flow maps have also been defined for numerical solutions of ODEs, by letting $\phi _ { t } ( \hat { z } _ { 0 } ) = I n t e g r a t o r ( z _ { 0 } , f , \{ t _ { i } \} _ { i = 0 } ^ { T } )$ with $t _ { 0 } = 0$ . We can extend this definition to all the trainable models we have considered, including the models based on O-NET and H-NET by defining $\phi _ { t } ( \hat { z } _ { 0 } )$ to be the state of the system after letting the system evolve from initial state $\hat { z } _ { 0 }$ for time $t$ , for suitable choices of $t$ . For example, for O-NET, we have $\phi _ { t } ( \hat { z } _ { 0 } ) = I n t e g r a t o r ( z _ { 0 } , f _ { \theta } , \{ t _ { i } \} _ { i = 0 } ^ { T } )$ .
+
+Suppose we impose an L2 loss on $\phi _ { t } ( \hat { z } _ { 0 } )$ , $e _ { t } ( \hat { z } _ { 0 } ) = \| \phi _ { t } ( \hat { z } _ { 0 } ) - z _ { t } \| _ { 2 } ^ { 2 }$ , where $z _ { t }$ corresponds to the observed data at time $t$ . The question is, is $e _ { t } ( z )$ a (perhaps locally) convex function of $z$ , for what functions and numerical integrators? To understand convexity, we compute the gradient and the Hessian as follow.
+
+$$
+\frac { \partial } { \partial z } e _ { t } ( z ) = 2 ( \phi _ { t } ( z ) - z _ { t } ) ^ { \mathsf { T } } \cdot F _ { t } ( z )
+$$
+
+$$
+\frac { \partial ^ { 2 } } { \partial z ^ { 2 } } e _ { t } ( z ) = 2 ( \phi _ { t } ( z ) - z _ { t } ) \cdot ^ { ( 3 ) } G _ { t } ( z ) + F _ { t } ( z ) ^ { \top } \cdot F _ { t } ( z ) ,
+$$
+
+where $F _ { t } ( z )$ is the Jacobian matrix of the flow map, defined as $\begin{array} { r } { F _ { t } ( z ) _ { i j } = \frac { \partial } { \partial z _ { j } } ( \phi _ { t } ( z ) _ { i } ) } \end{array}$ , and $G _ { t } ( z )$ is a third-order tensor contains the second order derivatives of the flow map, defined $\begin{array} { r } { G _ { t } ( z ) _ { i j k } = \frac { \partial ^ { 2 } } { \partial z _ { i } z _ { j } } ( \phi _ { t } ( z ) _ { k } ) } \end{array}$ ∂ 2 . We use ·(3) to denote the dot product in the third dimension.
+
+$F _ { t } ( z ) ^ { \mathsf { T } } \cdot F _ { t } ( z )$ is symmetric positive semidefinite for any matrix $F _ { t } ( z )$ . If $\phi _ { t }$ corresponds to either the exact flow map of a Hamiltonian system or the flow of a symplectic integrator, such as the leapfrog integrator, applied to a Hamiltonian system, then $F _ { t } ( z )$ is a symplectic matrix, implying that $\operatorname* { d e t } ( F _ { t } ( z ) ) = 1$ . Hence, $\mathrm { d e t } ( F _ { t } ( z ) ^ { \mathsf { T } } \cdot F _ { t } ( z ) ) = 1$ , which further implies that $F _ { t } ( z ) ^ { \mathsf { T } } \cdot F _ { t } ( z )$ is a positive definite matrix. Therefore, non-rigorously, when $\lVert \phi _ { t } ( z ) - z _ { t } \rVert _ { 2 }$ is small and so the first term on the right hand side of equation 16 is negligible compared to the least eigenvalue of $F _ { t } ( z ) ^ { \mathsf { T } } \cdot F _ { t } ( z )$ , the entire Hessian matrix ∂2∂z2 et(z) is also positive definite, implying strong convexity of the optimization problem.
+
+If $\phi _ { t }$ is the exact flow map, then $\| \phi _ { t } ( z ) - z _ { t } \|$ being small means that noise in the data is small. If $\phi _ { t }$ is the flow map of a learned model, then it means that we have a model close to the true underlying system in addition to not having too much noise in the data. Translating back to the learning problem, we see that, heuristically, when the model we use is close to symplectic, which is likely if the underlying system is a Hamiltonian system, and trained to be close enough to the true underlying system, and the noise in the data is small enough, then the optimization problem on the initial state is strongly convex.
+
+# D Additional plots of the spring-chain experiments D.1 Noiseless data (section 4.1)
+
+![](images/8699677295953d1b33056a30bb781e87e8c5814e60712547ba6548c7cd1a6c22.jpg)  
+Figure 5: Extension of Figure 1 to 10 masses on the chain (1st being the closest to one end, and $1 0 \mathrm { t h }$ being in the center).
+
+# D.2 Noisy data (section 4.2)
+
+![](images/e8c24983c3fed7cf6a51524359b7491dbc3fe35a3d656cc0408f581fb320a6a0.jpg)  
+Figure 6: Single-step E-E O-NET
+
+![](images/f62e89bb33fe289a5f0df489810eb6209ccf44ce6fa9a5ef14f8343c4eac118a.jpg)  
+Figure 7: Single-step E-E H-NET
+
+![](images/1d5eaa40baa0a9adb3bdfa97f37c5c61623ab810e84ef379d09259709df9b0e4.jpg)  
+Figure 8: Single-step L-L O-NET
+
+![](images/bb84020d14394637248edf3dde128a9af425810b173e863d12de5f7badcf873f.jpg)  
+Figure 9: Single-step L-L H-NET
+
+![](images/7674f229951c2cac24c31140a8aaae74f4f711ada20d1e1d4b4ad44b0f8351dd.jpg)  
+Figure 10: Recurrent E-E O-NET
+
+![](images/b984b2d7fc940f0c081de21685e85cab62c13266e79dfd784038cb20f8d48b4d.jpg)  
+Figure 11: Recurrent E-E H-NET
+
+![](images/d79ed8533c2414feaafacaffc61ee1cf39bf13c3bc22d69b657dfa347093f1b7.jpg)  
+Figure 12: Recurrent L-L O-NET
+
+![](images/9a21ffa9e2d59c98ed0251c75ddf083c188ef56ae61e6a4c1d5a34cc6c2f612a.jpg)  
+Figure 13: (SRNN) Recurrent L-L H-NET
+
+![](images/7d83acaa24389edd2280bbbaeec81b83c93918316c7c749434afef3ec1fa4a2e.jpg)  
+Figure 14: Recurrent E-E O-NET w/ ISO
+
+![](images/fc0f82d6f9d40437eaf549fc69e6d2a6e9f2529c8359d7eabe5e2d8357b51354.jpg)  
+Figure 15: Recurrent E-E H-NET w/ ISO
+
+![](images/58eef280515505d2d2a197f0815c1b5e745e524840a019420424404c881865fc.jpg)  
+Figure 16: Recurrent L-L O-NET w/ ISO
+
+![](images/d01575285c4fe0dbbb50cf80c42081c9b34cbce99ee011dfeae65ad2b7853cac.jpg)  
+Figure 17: (SRNN-ISO) Recurrent L-L H-NET w/ ISO
+
+![](images/244d9eb4162103278e38ebcf9f6c3fae6a695441df234562e62e061229592d61.jpg)  
+Figure 18: Vanilla RNN
+
+![](images/ba13579af38b65d9adb43b36d245df8956ec780539b558ba49a9813db37afa1a.jpg)  
+Figure 19: LSTM
+
+In each of the plots below, the three dashdot curves represent the ground truth trajectories of the three masses, and the three sequences of dots are the predictions made by each method.
+
+![](images/d97e59307a592699aa87a2c136a20f8f58f31165ceb40016c1a9bfa840d010cb.jpg)  
+Figure 20: Actual versus predicted trajectories of the three-body system by the various single-step-trained methods.
+
+![](images/7b7bb98223bf60995a9561b0de16df794c5e546d0f725610f8929d8788c2820f.jpg)  
+Figure 21: Actual versus predicted trajectories of the three-body system by the various recurrently trained methods.
+
+![](images/8e9d95c519606a34e4b13b0a5a508d99139fce19b7ab0939cd5f87effadb965c.jpg)  
+Figure 22: Actual trajectory versus the trajectory simulated by the leapfrog integrator with time-step 1 (left) and 0.1 (right).
+
+![](images/f4acf6f3d7bffc814663fb6df875bd940961e319078f2fc2fe7d07ac0fe6a8c2.jpg)  
+Figure 23: SRNN with a rebound module that does not learn $\alpha$ (and effectively treats $\alpha = 1$ ).
+
+![](images/6ec24284f2451ad19209823b16df140fe83f04db57f66c66e7e98db402039766.jpg)  
+Figure 24: SRNN without the rebound module.
+
+![](images/69faf379f7b86e81a31ac7cde5d9a6d26b838717c5ed192578fa109d9039f679.jpg)  
+Figure 25: Recurrent L-L O-NET with the rebound module.
+
+![](images/d8edef04ebcaf8356a642dab32e6e9738edbcd86e2f6c04891aa9dd60b00e959.jpg)  
+Figure 26: Vanilla RNN.

parse/train/S1lwRjR9YX/S1lwRjR9YX.md

@@ -0,0 +1,297 @@
+# STABILITY OF STOCHASTIC GRADIENT METHOD WITH MOMENTUM FOR STRONGLY CONVEX LOSS FUNCTIONS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+While momentum-based methods, in conjunction with the stochastic gradient descent, are widely used when training machine learning models, there is little theoretical understanding on the generalization error of such methods. In practice, the momentum parameter is often chosen in a heuristic fashion with little theoretical guidance. In this work we use the framework of algorithmic stability to provide an upper-bound on the generalization error for the class of strongly convex loss functions, under mild technical assumptions. Our bound decays to zero inversely with the size of the training set, and increases as the momentum parameter is increased. We also develop an upper-bound on the expected true risk, in terms of the number of training steps, the size of the training set, and the momentum parameter.
+
+# 1 INTRODUCTION
+
+A fundamental issue for any machine learning algorithm is its ability to generalize from the training dataset to the test data. A classical framework used to study the generalization error in machine learning is PAC learning (Vapnik and Chervonenkis, 1971; Valiant, 1984). However, the associated bounds using this approach can be conservative. Recently, the notion of uniform stability, introduced in the seminal work of Bousquet and Elisseeff (Bousquet and Elisseef, 2002), is leveraged to analyze the generalization error of the stochastic gradient method (SGM) (Hardt et al., 2016). The result in (Hardt et al., 2016) is a substantial step forward, since SGM is widely used in many practical systems. This method is scalable, robust, and widely adopted in a broad range of problems.
+
+To accelerate the convergence of SGM, a momentum term is often added in the iterative update of the stochastic gradient (Goodfellow et al., 2016). This approach has a long history, with proven benefits in various settings. The heavy-ball momentum method was first introduced by Polyak (Polyak, 1964), where a weighted version of the previous update is added to the current gradient update. Polyak motivated his method by its resemblance to a heavy ball moving in a potential well defined by the objective function. Momentum methods have been used to accelerate the backpropagation algorithm when training neural networks (Rumelhart et al., 1986). Intuitively, adding momentum accelerates convergence by circumventing sharp curvatures and long ravines of the sublevel sets of the objective function (Wilson et al., 2018). For example, Ochs et al. has presented an illustrative example to show that the momentum can potentially avoid local minima (Ochs et al., 2015). Nesterov has proposed an accelerated gradient method, which converges as $O ( 1 / k ^ { 2 } )$ where $k$ is the number of iterations (Nesterov, 1983). However, the Netstrov momentum does not seem to improve the rate of convergence for stochastic gradient (Goodfellow et al., 2016, Section 8.3.3). In this work, we focus on the heavy-ball momentum.
+
+Although momentum methods are well known to improve the convergence in SGM, their effect on the generalization error is not well understood. In this work, we first build upon the framework in (Hardt et al., 2016) to obtain a bound on the generalization error of SGM with momentum (SGMM) for the case of strongly convex loss functions. Our bound is independent of the number of training iterations and decreases inversely with the size of the training set. Secondly, we develop an upper-bound on the optimization error, which quantifies the gap between the empirical risk of SGMM and the global optimum. Our bound can be made arbitrarily small by choosing sufficiently many iterations and a sufficiently small learning rate. Finally, we establish an upper-bound on the expected true risk of SGMM as a function of various problem parameters. We note that the class of strongly convex loss functions appears in several important machine learning problems, including linear and logistic regression with a weight decay regularization term.
+
+Other related works: convergence analysis of first order methods with momentum is studied in (Nesterov, 1983; Ochs et al., 2014; Su et al., 2014; Ghadimi et al., 2015; Lessard et al., 2016; Yang et al., 2016; Loizou and Richtarik, 2018; Gadat et al., 2016). Most of these works consider the ´ deterministic setting for gradient update. Only a few works have analyzed the stochastic setting (Yang et al., 2016; Loizou and Richtarik, 2018; Gadat et al., 2016). Our convergence analysis ´ results are not directly comparable with these works due to their different assumptions regarding the properties of loss functions. In particular, we analyze the convergence of SGMM for a smooth and strongly convex loss function as in (Hardt et al., 2016), which is new.
+
+First-order methods with noisy gradient are studied in (Kidambi et al., 2018) and references therein. In (Kidambi et al., 2018), the authors show that there exists linear regression problems for which SGM outperforms SGMM in terms of convergence.
+
+Our main focus in this work is on the generalization, and hence true risk, of SGMM. We are aware of only one similar work in this regard, which provides stability bounds for quadratic loss functions (Chen et al., 2018). In this paper, we obtain stability bounds for the general case of strongly convex loss functions. In addition, unlike (Chen et al., 2018), our results show that machine learning models can be trained for multiple epochs of SGMM with bounded generalization errors.
+
+Notation: We use $\mathbb { E } [ \cdot ]$ to denote the expectation and $\| \cdot \|$ to represent the Euclidean norm of a vector. We use lower-case bold font to denote vectors. We use sans-serif font to denote random quantities. Sets and scalars are represented by calligraphic and standard fonts, respectively.
+
+# 2 GENERALIZATION ERROR AND STABILITY
+
+We consider a general supervised learning problem, where $\boldsymbol { S } = \{ \mathbf { z } _ { 1 } , \cdots , \mathbf { z } _ { n } \}$ denotes the set of samples of size $n$ drawn i.i.d. from some space $\mathcal { Z }$ with an unknown distribution $D$ . We assume a learning model described by parameter vector w. Let $f ( \mathbf { w } ; \mathbf { z } )$ denote the loss of the model described by parameter w on example $\mathbf { z } \in { \mathcal { Z } }$ . Our ultimate goal is to minimize the true or population risk:
+
+$$
+R ( \mathbf { w } ) \triangleq \mathbb { E } _ { \mathbf { z } \sim D } f ( \mathbf { w } ; \mathbf { z } ) .
+$$
+
+Since the distribution $D$ is unknown, we replace the objective by the empirical risk, i.e.,
+
+$$
+R _ { S } ( \mathbf { w } ) \triangleq \frac { 1 } { n } \sum _ { i = 1 } ^ { n } f ( \mathbf { w } ; \mathbf { z } _ { i } ) .
+$$
+
+We assume $\pmb { w } = A ( \mathcal { S } )$ for a potentially randomized algorithm $A ( \cdot )$ . In order to find an upper-bound on the true risk, we consider the generalization error, which is the expected difference of empirical and true risk:
+
+$$
+\epsilon _ { g } \triangleq \mathbb { E } _ { S , A } [ R ( A ( S ) ) - R _ { S } ( A ( S ) ) ] .
+$$
+
+Finally, to upper bound $\epsilon _ { g }$ , we consider uniform stability:
+
+Definition 1 Let $s$ and $S ^ { \prime }$ denote two data sets from space ${ \mathcal { Z } } ^ { n }$ such that $s$ and $S ^ { \prime }$ differ in at most one example. Algorithm $A$ is $\epsilon _ { s }$ -uniformly stable if for all data sets $s , s ^ { \prime }$ , we have
+
+$$
+\operatorname* { s u p } _ { \mathbf { z } } \mathbb { E } _ { A } [ f ( A ( { \cal S } ) ; \mathbf { z } ) - f ( A ( { \cal S } ^ { \prime } ) ; \mathbf { z } ) ] \leq \epsilon _ { s } .
+$$
+
+It is shown in (Hardt et al., 2016) that uniform stability implies generalization in expectation:
+
+Theorem 1 (Hardt et al., 2016) If $A$ is an $\epsilon _ { s }$ -uniformly stable algorithm, then the generalization error of $A$ is upper-bounded by $\epsilon _ { s }$ .
+
+Theorem 1 shows that it is enough to control the uniform stability of an algorithm to upper bound the generalization error.
+
+# 2.1 ASSUMPTIONS ON THE LOSS FUNCTION
+
+In our analysis, we will assume that the loss function satisfies the following properties.
+
+Definition 2 A function $f : \Psi  \mathbb { R }$ is $L$ -Lipschitz if for all $\mathbf { u }$ , $\mathbf { v } \in \Psi$ we have $| f ( \mathbf { u } ) - f ( \mathbf { v } ) | \leq$ $L \| \mathbf { u } - \mathbf { v } \|$ .
+
+Definition 3 A function $f : \Psi  \mathbb { R }$ is $\beta$ -smooth if for all $\mathbf { u }$ , $\mathbf { v } \in \Psi$ we have $\| \nabla f ( \mathbf { u } ) - \nabla f ( \mathbf { v } ) \| \leq$ $\beta \| \mathbf { u } - \mathbf { v } \|$ .
+
+Definition 4 A function $f : \Psi  \mathbb { R }$ is $\gamma$ -strongly convex if for all $\mathbf { u }$ , $\textbf { v } \in \ \Psi$ we have $f ( \mathbf { u } ) \geq$ $\begin{array} { r } { f ( \mathbf { v } ) + \nabla f ( \mathbf { v } ) ^ { \check { T } } ( \mathbf { u } - \mathbf { v } ) + \frac { \gamma } { 2 } \Vert \mathbf { u } - \mathbf { v } \Vert ^ { 2 } } \end{array}$ .
+
+We assume that the parameter space $\Omega$ is a convex set. Furthermore, for the loss function to be $L$ -Lipschitz and and strongly convex, we further assume that $\Omega$ is compact. Since $\Omega$ is compact, the SGMM update requires projection.
+
+# 2.2 STOCHASTIC GRADIENT METHOD WITH MOMENTUM
+
+The update rule for projected SGMM is given by:
+
+$$
+\mathbf { w } _ { t + 1 } = \mathbf { P } \left( \mathbf { w } _ { t } + \mu ( \mathbf { w } _ { t } - \mathbf { w } _ { t - 1 } ) - \alpha \nabla _ { \mathbf { w } } f ( \mathbf { w } _ { t } ; \mathbf { z } _ { \mathrm { i } _ { t } } ) \right)
+$$
+
+where $\mathbf { P }$ denotes the Euclidean projection onto $\Omega$ , $\alpha > 0$ is the learning rate1, $\mu > 0$ is the momentum parameter, $\mathsf { i } _ { t }$ is a randomly selected index, and $f ( \mathbf { w } _ { t } ; \mathbf { z } _ { \mathrm { i } _ { t } } )$ is the loss evaluated on sample $\mathbf { z } _ { \mathrm { i } _ { t } }$ . In SGMM, we run the update (5) iteratively for $T$ steps and let ${ \pmb w } _ { T }$ denote the final output. Note that there are two typical approaches to select $\mathsf { i } _ { t }$ . The first approach is to select $\mathsf { i } _ { t } \in \{ 1 , \cdots , n \}$ uniformly at random at each iteration. The second approach is to permutate $\{ 1 , \cdots , n \}$ randomly once and then select the examples repeatedly in a cyclic manner. Our results are valid for both approaches. The key quantity of interest in this paper is the generalization error for SGMM given by:
+
+$$
+\epsilon _ { g } = \mathbb { E } _ { S , A } [ R ( \mathbf { w } _ { T } ) - R _ { S } ( \mathbf { w } _ { T } ) ] = \mathbb { E } _ { S , \mathrm { i } _ { 0 } , \cdots , \mathrm { i } _ { T - 1 } } [ R ( \mathbf { w } _ { T } ) - R _ { S } ( \mathbf { w } _ { T } ) ]
+$$
+
+since the randomness in $A$ arises from the choice of $\mathrm { i } _ { 0 } , \cdots , \mathrm { i } _ { T - 1 }$
+
+# 3 MAIN RESULTS
+
+In the following, we assume that the loss function $f ( \cdot ; \mathbf { z } )$ is $\beta$ -smooth, $L$ -Lipschitz, and $\gamma$ -strongly convex for all $\mathbf { z }$ .
+
+Theorem 2 (Stability bound) Suppose that the SGMM update (5) is executed for $T$ steps with constant learning rate $\alpha$ and momentum $\mu$ . Provided that $\begin{array} { r } { \frac { \alpha \beta \gamma } { \beta + \gamma } - \frac { 1 } { 2 } \leq \mu < \frac { \alpha \beta \gamma } { 3 ( \beta + \gamma ) } } \end{array}$ and $\begin{array} { r } { \alpha \le \frac { 2 } { \beta + \gamma } } \end{array}$ , SGMM satisfies $\epsilon _ { s }$ -uniform stability where
+
+$$
+\epsilon _ { s } \leq \frac { 2 \alpha L ^ { 2 } ( \beta + \gamma ) } { n \big ( \alpha \beta \gamma - 3 \mu ( \beta + \gamma ) \big ) } .
+$$
+
+The result in Theorem 2 implies that the stability bound decreases inversely with the size of the training set. It increases as the momentum parameter $\mu$ increases. These properties are also verified in our experimental evaluation.
+
+Theorem 3 (Convergence bound) Suppose that the SGMM update (5) is executed for $T$ steps with constant learning rate $\alpha$ and momentum $\mu$ . Then we have
+
+$$
+\mathbb { E } _ { S , A } [ R _ { S } ( \hat { \mathbf { w } } _ { T } ) - R _ { S } ( \mathbf { w } _ { S } ^ { * } ) ] \leq \frac { \mu W _ { 0 } } { ( 1 - \mu ) T } + \frac { ( 1 - \mu ) W _ { 1 } } { 2 \alpha T } - \frac { \gamma W _ { 2 } } { 2 } - \frac { \mu \gamma W _ { 3 } } { 2 ( 1 - \mu ) } + \frac { \alpha L ^ { 2 } } { 2 ( 1 - \mu ) }
+$$
+
+where $\hat { \mathbf { w } } _ { T }$ denotes the average of $T$ steps of the algorithm, i.e., $\begin{array} { r } { \hat { \mathbf { w } } _ { T } = \frac { 1 } { T + 1 } \sum _ { t = 0 } ^ { T } \mathbf { w } _ { t } } \end{array}$ , $R _ { S } ( \mathbf { w } ) =$ $\begin{array} { r } { \frac 1 n \sum _ { i = 1 } ^ { n } f ( \mathbf { w } ; \mathbf { z } _ { i } ) , \mathbf { w } _ { S } ^ { * } = \arg \operatorname* { m i n } _ { \mathbf { w } } R _ { S } ( \mathbf { w } ) , } \end{array}$ $W _ { 0 } = \mathbb { E } _ { S , A } [ R _ { S } ( \mathbf { w } _ { 0 } ) - R _ { S } ( \mathbf { w } _ { T } ) ] ,$ , $W _ { 1 } = \mathbb { E } _ { S , A } [ \| \mathbf { w } _ { 0 } -$ $\pmb { w } _ { S } ^ { * } \| ^ { 2 } \|$ , $W _ { 2 } = \mathbb { E } _ { S , A } [ \| \hat { \mathbf { w } } _ { T } - \mathbf { w } _ { S } ^ { * } \| ^ { 2 } ] _ { }$ , and $\begin{array} { r } { W _ { 3 } = \frac { 1 } { T + 1 } \sum _ { t = 0 } ^ { T } \mathbb { E } _ { S , A } [ \| \mathbf { w } _ { t } - \mathbf { w } _ { t - 1 } \| ^ { 2 } ] } \end{array}$ .
+
+Theorem 3 bounds the optimization error, i.e., the expected difference between the empirical risk achieved by SGMM and the global minimum. Upon setting $\mu = 0$ and $\gamma = 0$ in (7), we can recover the classical bound on optimization error for SGM (Nemirovski and Yudin., 1983), (Hardt et al., 2016, Theorem 5.2). The first two terms in (7) vanish as $T$ increases. The terms with negative sign improve the convergence due to the strongly convexity. The last term depends on the learning rate, $\alpha$ , the momentum parameter $\mu$ , and the Lipschitz constant $L$ . This term can be controlled by selecting $\alpha$ sufficiently small.
+
+Proposition 1 (Upper-bound on true risk) Suppose that the SGMM update (5) is executed for $T$ steps with constant learning rate $\alpha$ and momentum $\mu$ , satisfying the conditions in Theorem 2 and $\mu ( \beta + \gamma ) \ll \alpha \beta \gamma .$ . Then, setting $\begin{array} { r } { \alpha = \frac { 1 - \mu } { L } \sqrt { \frac { W _ { 1 } } { T } } } \end{array}$ W1T , we have:
+
+$$
+\mathbb { E } _ { S , A } [ R ( \hat { \mathbf { w } } _ { T } ) ] \leq \mathbb { E } _ { S , A } [ R _ { S } ( \mathbf { w } _ { S } ^ { * } ) ] + \frac { \mu W _ { 0 } } { ( 1 - \mu ) T } + L \sqrt { \frac { W _ { 1 } } { T } } - \frac { \gamma W _ { 2 } } { 2 } - \frac { \mu \gamma W _ { 3 } } { 2 ( 1 - \mu ) } + \frac { 2 L ^ { 2 } ( \beta + \gamma ) } { n \beta \gamma C }
+$$
+
+where C ∆= 1− 3µL(β+γ) T√ and $\hat { \mathbf { w } } _ { T }$ as well as the constants $W _ { 0 } , \cdots , W _ { 3 }$ are defined in Theorem 3.
+
+Proposition 1 provides a bound on the expected true risk of SGMM in terms of the global minimum of the empirical risk. The bound in (8) is obtained by combining Theorem 2 and Theorem 3 and minimizing the expression over $\alpha$ . The choice of $\alpha$ simplifies considerably when $\mu$ is sufficiently small, as stated in Proposition 1. Due to the page constraint, the proof of this result is provided in the supplementary material. Note that the first two terms in (8) vanish as $T$ increases. The last term in (8) vanishes as the number of samples $n$ increases.
+
+# 4 PROOF OF THEOREM 2 (STABILITY BOUND)
+
+Following (Hardt et al., 2016), we track the divergence of two different iterative sequences of update rules with the same starting point. However, our analysis is more involved as the presence of momentum term requires a more careful bound on the iterative expressions.
+
+To keep the notation uncluttered, we first consider SGMM without projection and defer the discussion of projection to the end of this proof. Let $S = \{ \mathbf { z } _ { 1 } , \cdots , \mathbf { z } _ { n } \}$ and $S ^ { \prime } = \{ \mathbf { z } _ { 1 } ^ { \prime } , \cdot \cdot \cdot , \mathbf { z } _ { n } ^ { \prime } \}$ be two samples of size $n$ that differ in at most one example. Let ${ \pmb w } _ { T }$ and ${ \bf w } _ { T } ^ { \prime }$ denote the outputs of SGMM on $s$ and $S ^ { \prime }$ , respectively. We consider the updates $\mathbf { w } _ { t + 1 } = G _ { t } ( \mathbf { w } _ { t } ) + \mu ( \mathbf { w } _ { t } - \mathbf { w } _ { t - 1 } )$ and $\boldsymbol { \mathsf { w } } _ { t + 1 } ^ { \prime } =$ $G _ { t } ^ { \prime } ( \mathbf { w } _ { t } ^ { \prime } ) + \mu ( \mathbf { w } _ { t } ^ { \prime } - \mathbf { w } _ { t - 1 } ^ { \prime } )$ with $G _ { t } ( \mathbf { w } _ { t } ) = \mathbf { w } _ { t } - \alpha \nabla _ { \mathbf { w } } f ( \dot { \mathbf { w } } _ { t } ; \mathbf { z } _ { \mathrm { i } _ { t } } )$ and $G _ { t } ^ { \prime } ( \mathbf { w } _ { t } ^ { \prime } ) = \mathbf { w } _ { t } ^ { \prime } - \alpha \nabla _ { \mathbf { w } } f ( \mathbf { w } _ { t } ^ { \prime } ; \mathbf { z } _ { \mathfrak { i } _ { t } } ^ { \prime } )$ , respectively, for $t = 1 , \cdots , T$ . We denote $\delta _ { t } \triangleq \Vert \mathbf { w } _ { t } - \mathbf { w } _ { t } ^ { \prime } \Vert$ . Suppose $\pmb { w } _ { 0 } = \pmb { w } _ { 0 } ^ { \prime }$ , i.e., $\delta _ { 0 } = 0$ . We first establish an upper-bound on $\mathbb { E } _ { A } [ \delta _ { t + 1 } ]$ in terms of $\mathbb { E } _ { A } [ \delta _ { t } ]$ and $\mathbb { E } _ { A } [ \delta _ { t - 1 } ]$ in the following lemma, whose proof is provided in the supplementary document.
+
+Lemma 1 Provided that $\begin{array} { r } { \alpha \leq \frac { 2 } { \beta + \gamma } } \end{array}$ , an upper-bound on $\mathbb { E } _ { A } [ \delta _ { t + 1 } ]$ is given by
+
+$$
+\mathbb { E } _ { A } [ \delta _ { t + 1 } ] \leq \Big ( 1 + \mu - \frac { \alpha \beta \gamma } { \beta + \gamma } \Big ) \mathbb { E } _ { A } [ \delta _ { t } ] + \mu \mathbb { E } _ { A } [ \delta _ { t - 1 } ] + \frac { 2 \alpha L } { n } .
+$$
+
+Using the result of Lemma 1, in the following, we develop an upper bound on $\mathbb { E } _ { A } [ \delta _ { T } ]$ . Let us consider the recursion
+
+$$
+\mathbb { E } _ { A } [ \tilde { \delta } _ { t + 1 } ] = \Big ( 1 + \mu - \frac { \alpha \beta \gamma } { \beta + \gamma } \Big ) \mathbb { E } _ { A } [ \tilde { \delta } _ { t } ] + \mu \mathbb { E } _ { A } [ \tilde { \delta } _ { t - 1 } ] + \frac { 2 \alpha L } { n }
+$$
+
+with $\tilde { \delta } _ { 0 } = \delta _ { 0 } = 0$ . Upon inspecting (10) it is clear that
+
+$$
+\mathbb { E } _ { A } [ \tilde { \delta } _ { t } ] \geq \big ( 1 + \mu - \frac { \alpha \beta \gamma } { \beta + \gamma } \big ) \mathbb { E } _ { A } [ \tilde { \delta } _ { t - 1 } ] , \qquad \forall t \geq 1 ,
+$$
+
+as we simply drop the remainder of positive terms. Substituting (11) into (10), we have
+
+$$
+\begin{array} { l } { \displaystyle \mathbb { E } _ { A } [ \tilde { \delta } _ { t + 1 } ] \leq \Big ( 1 + \mu + \frac { \mu } { 1 + \mu - \frac { \alpha \beta \gamma } { \beta + \gamma } } - \frac { \alpha \beta \gamma } { \beta + \gamma } \Big ) \mathbb { E } _ { A } [ \tilde { \delta } _ { t } ] + \frac { 2 \alpha L } { n } } \\ { \displaystyle \qquad \leq \Big ( 1 + 3 \mu - \frac { \alpha \beta \gamma } { \beta + \gamma } \Big ) \mathbb { E } _ { A } [ \tilde { \delta } _ { t } ] + \frac { 2 \alpha L } { n } } \end{array}
+$$
+
+$\begin{array} { r } { \mu \geq \frac { \alpha \beta \gamma } { \beta + \gamma } - \frac { 1 } { 2 } } \end{array}$
+
+Noting that $\mathbb { E } _ { A } [ \tilde { \delta } _ { t } ] \geq \mathbb { E } _ { A } [ \delta _ { t } ]$ for all $t$ including $T$ , we have
+
+$$
+\mathbb { E } _ { A } [ \delta _ { T } ] \le \frac { 2 \alpha L } { n } \sum _ { t = 1 } ^ { T } \Big ( 1 + 3 \mu - \frac { \alpha \beta \gamma } { \beta + \gamma } \Big ) ^ { t } \le \frac { 2 \alpha L ( \beta + \gamma ) } { n \big ( \alpha \beta \gamma - 3 \mu ( \beta + \gamma ) \big ) }
+$$
+
+where the second expression holds since 0 ≤ µ < αβγ3(β+γ) is assumed.
+
+Applying the $L$ -Lipschitz property on $f ( \cdot , \mathbf { z } )$ , it follows that
+
+$$
+\mathbb { E } _ { A } [ | f ( \mathbf { w } _ { T } ; \mathbf { z } ) - f ( \mathbf { w } _ { T } ^ { \prime } ; \mathbf { z } ) | ] \leq L \mathbb { E } _ { A } [ \delta _ { T } ] \leq \frac { 2 \alpha L ^ { 2 } ( \beta + \gamma ) } { n \big ( \alpha \beta \gamma - 3 \mu ( \beta + \gamma ) \big ) } .
+$$
+
+Since this bound holds for all $s , s ^ { \prime }$ and $\mathbf { z }$ , we obtain an upper-bound on the uniform stability and the proof is complete. Our stability bound in Theorem 2 holds for the projected SGMM update (5) because Euclidean projection does not increase the distance between projected points (the argument is essentially analogous to (Hardt et al., 2016, Lemma 4.6)). In particular, note that Lemma 1 holds for the projected SGMM.
+
+# 5 PROOF OF THEOREM 3 (CONVERGENCE BOUND)
+
+Again, we first consider SGMM without projection and discuss the extension to projection at the end of this proof. Our proof is inspired by the convergence analysis in (Yang et al., 2016; Ghadimi et al., 2015) for a convex loss function with bounded variance and time-decaying learning rate. Different from these works, we analyze the convergence of SGMM for a smooth and strongly convex loss function with constant learning rate. To facilitate the convergence analysis, we define:
+
+$$
+\mathbf p _ { t } \triangleq \frac { \mu } { 1 - \mu } ( \mathbf w _ { t } - \mathbf w _ { t - 1 } )
+$$
+
+with $\pmb { \mathrm { p } } _ { 0 } = 0$ . Substituting into the SGMM update, the parameter recursion is given by
+
+$$
+\mathbf { w } _ { t + 1 } + \mathbf { p } _ { t + 1 } = \mathbf { w } _ { t } + \mathbf { p } _ { t } - { \frac { \alpha } { 1 - \mu } } \nabla _ { \mathbf { w } } f ( \mathbf { w } _ { t } ; \mathbf { z } _ { \mathrm { i } _ { t } } )
+$$
+
+It follows that
+
+$$
+\begin{array} { l } { \displaystyle \| { \bf w } _ { t + 1 } + { \bf p } _ { t + 1 } - { \bf w } \| ^ { 2 } = \| { \bf w } _ { t } + { \bf p } _ { t } - { \bf w } \| ^ { 2 } + \big ( \frac { \alpha } { 1 - \mu } \big ) ^ { 2 } \| \nabla _ { { \bf w } } f ( { \bf w } _ { t } ; { \bf z } _ { \mathrm { i } _ { t } } ) \| ^ { 2 } } \\ { \displaystyle \qquad - \frac { 2 \alpha } { 1 - \mu } ( { \bf w } _ { t } + { \bf p } _ { t } - { \bf w } ) ^ { T } \nabla _ { { \bf w } } f ( { \bf w } _ { t } ; { \bf z } _ { \mathrm { i } _ { t } } ) . } \end{array}
+$$
+
+Substituting $\mathbf { p } _ { t }$ (15) into (17), the recursion (16) can be written as
+
+$$
+\begin{array} { l } { { \displaystyle { \bf w } _ { t + 1 } + { \bf p } _ { t + 1 } - { \bf w } \| ^ { 2 } = \| { \bf w } _ { t } + { \bf p } _ { t } - { \bf w } \| ^ { 2 } + \big ( \frac { \alpha } { 1 - \mu } \big ) ^ { 2 } \| \nabla _ { { \bf w } } f ( { \bf w } _ { t } ; { \bf z } _ { { \bf i } _ { t } } ) \| ^ { 2 } } \ ~ } \\ { { \displaystyle \phantom { \frac { 1 } { 1 + \mu } } - \frac { 2 \alpha \mu } { ( 1 - \mu ) ^ { 2 } } ( { \bf w } _ { t } - { \bf w } _ { t - 1 } ) ^ { T } \nabla _ { { \bf w } } f ( { \bf w } _ { t } ; { \bf z } _ { { \bf i } _ { t } } ) - \frac { 2 \alpha } { 1 - \mu } ( { \bf w } _ { t } - { \bf w } ) ^ { T } \nabla _ { { \bf w } } f ( { \bf w } _ { t } ; { \bf z } _ { { \bf i } _ { t } } ) } . } \end{array}
+$$
+
+Upon taking the expectation with respect to $\mathsf { i } _ { t }$ in (18) we have
+
+$$
+\begin{array} { c } { \displaystyle \mathfrak { l } _ { t } \| \mathbf { w } _ { t + 1 } + \mathbf { p } _ { t + 1 } - \mathbf { w } \| ^ { 2 } \leq \| \mathbf { w } _ { t } + \mathbf { p } _ { t } - \mathbf { w } \| ^ { 2 } + \big ( \displaystyle \frac { \alpha } { 1 - \mu } \big ) ^ { 2 } L ^ { 2 } - \displaystyle \frac { 2 \alpha \mu } { ( 1 - \mu ) ^ { 2 } } \big ( \mathbf { w } _ { t } - \mathbf { w } _ { t - 1 } \big ) ^ { T } \nabla _ { \mathbf { w } } R _ { S } ( \mathbf { w } _ { t } ) } \\ { \displaystyle - \displaystyle \frac { 2 \alpha } { 1 - \mu } ( \mathbf { w } _ { t } - \mathbf { w } ) ^ { T } \nabla _ { \mathbf { w } } R _ { S } ( \mathbf { w } _ { t } ) } \end{array}
+$$
+
+where we use the fact that $\left\| \nabla _ { \mathbf { w } } f ( \mathbf { w } _ { t } ; \mathbf { z } _ { \mathsf { i } _ { t } } ) \right\| \leq L$ , due to $L$ -Lipschitz, and that $\mathbb { E } _ { \mathbf { i } _ { t } } [ \nabla _ { \mathbf { w } } f ( \mathbf { w } _ { t } ; \mathbf { z } _ { \mathbf { i } _ { t } } ) ] =$ $\nabla _ { \mathbf { w } } R _ { S } ( \mathbf { w } _ { t } )$ . Furthermore, since $R _ { S } ( \cdot )$ is a $\gamma$ -strongly convex function, for all $\mathbf { w } _ { t }$ and $\mathbf { w } _ { t - 1 }$ , we have
+
+$$
+\begin{array} { r l } & { \quad ( \mathbf { w } _ { t } - \mathbf { w } ) ^ { T } \nabla _ { \mathbf { w } } R _ { S } ( \mathbf { w } _ { t } ) \geq R _ { S } ( \mathbf { w } _ { t } ) - R _ { S } ( \mathbf { w } ) + \displaystyle \frac { \gamma } { 2 } \| \mathbf { w } _ { t } - \mathbf { w } \| ^ { 2 } , } \\ & { \quad ( \mathbf { w } _ { t } - \mathbf { w } _ { t - 1 } ) ^ { T } \nabla _ { \mathbf { w } } R _ { S } ( \mathbf { w } _ { t } ) \geq R _ { S } ( \mathbf { w } _ { t } ) - R _ { S } ( \mathbf { w } _ { t - 1 } ) + \displaystyle \frac { \gamma } { 2 } \| \mathbf { w } _ { t } - \mathbf { w } _ { t - 1 } \| ^ { 2 } . } \end{array}
+$$
+
+Substituting (20) in (19), we have
+
+$$
+\begin{array} { r } { \displaystyle \mathfrak { L } _ { i _ { t } } \big [ | \mathbf { w } _ { t + 1 } + \mathbf { p } _ { t + 1 } - \mathbf { w } | ^ { 2 } \big ] \leq \| \mathbf { w } _ { t } + \mathbf { p } _ { t } - \mathbf { w } \| ^ { 2 } - \frac { \alpha \gamma } { 1 - \mu } \| \mathbf { w } _ { t } - \mathbf { w } \| ^ { 2 } - \frac { 2 \alpha \mu } { ( 1 - \mu ) ^ { 2 } } \big ( R _ { S } ( \mathbf { w } _ { t } ) - R _ { S } ( \mathbf { w } _ { t - 1 } ) } \\ { \displaystyle - \frac { 2 \alpha } { 1 - \mu } \big ( R _ { S } ( \mathbf { w } _ { t } ) - R _ { S } ( \mathbf { w } ) \big ) + \frac { \alpha ^ { 2 } L ^ { 2 } } { ( 1 - \mu ) ^ { 2 } } - \frac { \alpha \mu \gamma } { ( 1 - \mu ) ^ { 2 } } \| \mathbf { w } _ { t } - \mathbf { w } _ { t - 1 } \| ^ { 2 } . } \end{array}
+$$
+
+Taking expectation over $\mathrm { i } _ { 0 } , \cdots , \mathrm { i } _ { t }$ for a given $s$ , summing (21) for $t = 0 , \cdots , T$ , and rearranging terms, we have
+
+$$
+\begin{array} { r l r } {  { \frac { 2 \alpha } { 1 - \mu } \sum _ { t = 0 } ^ { T } \mathbb { E } _ { A } \big [ R _ { S } ( \mathbf { w } _ { t } ) - R _ { S } ( \mathbf { w } ) \big ] \leq \frac { 2 \alpha \mu } { ( 1 - \mu ) ^ { 2 } } \mathbb { E } _ { A } \big [ R _ { S } ( \mathbf { w } _ { 0 } ) - R _ { S } ( \mathbf { w } _ { T } ) \big ] - \frac { \alpha \gamma } { 1 - \mu } \sum _ { t = 0 } ^ { T } \mathbb { E } _ { A } \big [ \| \mathbf { w } _ { t } - \mathbf { w } \| ^ { 2 } \big ] } } \\ & { } & { \qquad - \frac { \alpha \mu \gamma } { ( 1 - \mu ) ^ { 2 } } \sum _ { t = 0 } ^ { T } \mathbb { E } _ { A } \big [ \| \mathbf { w } _ { t } - \mathbf { w } _ { t - 1 } \| ^ { 2 } \big ] + \mathbb { E } _ { A } \big [ \| \mathbf { w } _ { 0 } - \mathbf { w } \| ^ { 2 } \big ] + \frac { \alpha ^ { 2 } L ^ { 2 } ( T + 1 ) } { ( 1 - \mu ) ^ { 2 } } . \qquad ( 2 2 ) } \end{array}
+$$
+
+Since $\| \cdot \|$ is a convex function, for all $\mathbf { w } _ { T }$ and w, we have
+
+$$
+\| \hat { \mathbf { w } } _ { T } - \mathbf { w } \| ^ { 2 } \leq \frac { 1 } { T + 1 } \sum _ { t = 0 } ^ { T } \| \mathbf { w } _ { t } - \mathbf { w } \| ^ { 2 } .
+$$
+
+Furthermore, due to convexity of $R _ { S } ( \cdot )$ , we have
+
+$$
+R _ { S } ( \hat { \mathbf { w } } _ { T } ) - R _ { S } ( \mathbf { w } ) \leq \frac { 1 } { T + 1 } \sum _ { t = 0 } ^ { T } \big ( R _ { S } ( \mathbf { w } _ { t } ) - R _ { S } ( \mathbf { w } ) \big ) .
+$$
+
+Taking expectation over $s$ , applying inequalities (23) and (24) into (22), and substituting $\mathbf { w } = \mathbf { w } _ { S } ^ { * }$ , we obtain (7) and the proof is complete.
+
+Our convergence bound in Theorem 3 can be extended to projected SGMM (5). Let use denote 1 ∆= wt + µ(wt − wt−1) − α∇wf (wt; zit ). Then, for any feasible w ∈ Ω, (17) holds for yt+1, i.e.,
+
+$$
+\begin{array} { l } { \displaystyle \| { \bf y } _ { t + 1 } + \frac { \mu } { 1 - \mu } ( { \bf y } _ { t + 1 } - { \bf w } _ { t } ) - { \bf w } \| ^ { 2 } = \| { \bf w } _ { t } + { \bf p } _ { t } - { \bf w } \| ^ { 2 } + \big ( \frac { \alpha } { 1 - \mu } \big ) ^ { 2 } \| \nabla _ { \bf w } f ( { \bf w } _ { t } ; { \bf z } _ { \mathrm { i } _ { t } } ) \| ^ { 2 } } \\ { \displaystyle - \frac { 2 \alpha } { 1 - \mu } ( { \bf w } _ { t } + { \bf p } _ { t } - { \bf w } ) ^ { T } \nabla _ { \bf w } f ( { \bf w } _ { t } ; { \bf z } _ { \mathrm { i } _ { t } } ) . } \end{array}
+$$
+
+Note that the LHS of (25) can be written as
+
+$$
+\| { \bf y } _ { t + 1 } + \frac { \mu } { 1 - \mu } ( { \bf y } _ { t + 1 } - { \bf w } _ { t } ) - { \bf w } \| ^ { 2 } = \frac { 1 } { 1 - \mu } \| { \bf y } _ { t + 1 } - \left( \mu { \bf w } _ { t } + ( 1 - \mu ) { \bf w } \right) \| .
+$$
+
+We note that $\mu \mathbf { w } _ { t } + ( 1 - \mu ) \mathbf { w } \in \Omega$ for any $\mathbf { w } \in \Omega$ and $\boldsymbol { \mathsf { w } } _ { t } \in \Omega$ since $\Omega$ is convex.
+
+Now in projected SGMM, we have
+
+$$
+\begin{array} { r l } & { \| \mathbf { w } _ { t + 1 } - \big ( \mu \mathbf { w } _ { t } + ( 1 - \mu ) \mathbf { w } \big ) \| ^ { 2 } = \| \mathbf { P } ( \mathbf { y } _ { t + 1 } ) - \big ( \mu \mathbf { w } _ { t } + ( 1 - \mu ) \mathbf { w } \big ) \| ^ { 2 } } \\ & { \qquad \leq \| \mathbf { y } _ { t + 1 } - \big ( \mu \mathbf { w } _ { t } + ( 1 - \mu ) \mathbf { w } \big ) \| ^ { 2 } } \end{array}
+$$
+
+since projection a point onto $\Omega$ moves it closer to any point in $\Omega$ . This shows inequality (19) holds, and the convergence results do not change.
+
+![](images/994112fa98c557084cc8d4db0f0317d8f5bc957f66c54c3ce88a4f49e9a50774.jpg)  
+Figure 1: Generalization performance (cross entropy) of logistic regression for notMNIST dataset with $T = 1 0 0 0$ iterations and minibatch size 10.
+
+![](images/3e79fc910d33315a92ac80f4e92d5f92a2a5a1c06dff17ec37a97d199ab63f73.jpg)  
+Figure 2: Generalization performance (classification accuracy) of logistic regression for notMNIST dataset with $T = 1 0 0 0$ iterations and minibatch size 10.
+
+# 6 EXPERIMENTAL EVALUATION
+
+In this section, we validate the insights obtained in our theoretical results in experimental evaluation. Our main goal is to study how adding momentum affects the convergence and generalization of SGM. We study the performance of SGMM when applied to the notMINIST dataset. Please note that similar results are provided for the MNIST dataset in the supplementary document. We train a logistic regression model with the weight decay regularization using SGMM for binary classification on the two-class notMNIST dataset that contains the images from letter classes “C” and “J”, which leads to a smooth and strongly convex loss function. We set the learning rate $\alpha = 0 . 0 1$ . The weight decay coefficient and the minibatch size are set to 0.001 and 10, respectively. We use 100 SGMM realizations to evaluate the average performance. We compare the training and generalization performance of SGM without momentum with that of SGMM under $\mu = 0 . 5$ and $\mu = 0 . 9$ , which are common momentum values used in practice (Goodfellow et al., 2016, Section 8.3.2).
+
+The generalization error (with respect to cross entropy) and training error versus the number of training samples, $n$ , under SGMM with fixed $T = 1 0 0 0$ iterations are shown in Figures 1a and 1b, respectively, for $\mu = 0 , 0 . 5 , 0 . 9$ . In Figures 2a and 2b, we plot the generalization error (with respect to classification accuracy) and the training accuracy as a function of the number of training samples for the same dataset. First, we observe that the generalization error (with respect to both cross entropy and classification accuracy) decreases as $n$ increases for all values of $\mu$ , which is suggested by our stability upper-bound in Theorem 2. In addition, for sufficiently large $n$ , we observe that the generalization error increases with $\mu$ , consistent with Theorem 2. On the other hand, the training error increases as $n$ increases, which is expected. We can observe that adding momentum reduces training error as it improves the convergence rate. The training accuracy also improves by adding momentum as illustrated in Fig. 2b.
+
+![](images/cdbcbe27e7037e8c104271d33ddc10a05d31f9a3ea6f70372dd14653bc1002b7.jpg)  
+Figure 3: Training and test error of logistic regression (cross entropy loss) for notMNIST dataset with $n = 5 0 0$ training samples and minibatch size 10.
+
+![](images/096173fc5eb627de5b927381f209c0dbad50fd8f4ce7f7c7d226702b3b0499e2.jpg)  
+Figure 4: Training and test accuracy of logistic regression for notMNIST dataset with $n = 5 0 0$ training samples and minibatch size 10.
+
+In order to study the optimization error of SGMM, we show the training error and test error versus the number of epochs, under SGMM trained with $n = 5 0 0$ samples in Figures 3a and 3b, respectively. We plot the classification accuracy for training and test datasets in Figures 4a and 4b, respectively. We observe that the training error decreases as the number of epochs increases for all values of $\mu$ , which is consistent with the convergence analysis in Theorem 3. Furthermore, as expected, we see that adding momentum improves the training error and accuracy. However, as the number of epochs increases, we note that the benefit of momentum on the test error and accuracy becomes negligible. This happens because adding momentum also results in a higher generalization error thus penalizing the gain in training error.
+
+# 7 CONCLUSIONS
+
+We study the generalization error and convergence of SGMM for the class of strongly convex loss functions, under mild technical conditions. We establish an upper-bound on the generalization error, which decreases with the size of the training set, and increases as the momentum parameter is increased. Secondly, we analyze the convergence of SGMM during training, by establishing an upper-bound on the gap between the empirical risk of SGMM and the global minimum. Our proposed bound reduces to a classical bound on the optimization error of SGM (Nemirovski and Yudin., 1983) for convex functions, when the momentum parameter is set to zero. Finally, we establish an upper-bound on the expected difference between the true risk of SGMM and the global minimum of the empirical risk, and illustrate how it scales with the number of training steps and the size of the training set. Although our results are established for the case when the learning rate is constant, they can be easily extended to the case when the learning rate decreases with the number of iterations. We also present experimental evaluations on the notMNIST dataset and show that the numerical plots are consistent with our theoretical bounds on the generalization error and the convergence gap.
+
+REFERENCES   
+V. N. Vapnik and A. Y. Chervonenkis. On the uniform convergence of relative frequencies of events to their probabilities. Theory of Probability and Its Applications, 16(2):264–280, 1971.   
+L. G. Valiant. A theory of the learnable. Communications of the ACM, 27(11):1134–1142, 1984.   
+O. Bousquet and A. Elisseef. Stability and generalization. Journal of Machine Learning Research, 2:499–526, 2002.   
+M. Hardt, B. Recht, and Y Singer. Train faster, generalize better: Stability of stochastic gradient descent. Preprint available at arXiv:1509.01240v2, 2016.   
+I. Goodfellow, Y. Bengio, and A. Courville. Deep Learning. Cambridge, USA: The MIT Press, 2016.   
+B. T. Polyak. Some methods of speeding up the convergence of iteration methods. USSR Computational Mathematics and Mathematical Physics, 4(5):1–17, 1964.   
+D. E. Rumelhart, G. E. Hinton, and R. J. Williams. Learning representations by backpropagating errors. Nature, 323:533–536, 1986.   
+A. C. Wilson, B. Recht, and M. I. Jordan. A lyapunov analysis of momentum methods in optimization. Preprint available at arXiv:1611.02635v4, 2018.   
+P. Ochs, T. Brox, and T. Pock. IPIASCO: Inertial proximal algorithm for strongly convex optimization. Journal of Mathematical Imaging and Vision, 53(2):171–181, 2015.   
+Y. Nesterov. A method of solving a convex programming problem with convergence $O ( 1 / k ^ { 2 } )$ . Soviet Mathematics Doklady, 27(2):372–376, 1983.   
+P. Ochs, Y. Chen, T. Brox, and T. Pock. IPIANO: Inertial proximal algorithm for nonconvex optimization. SIAM Journal on Imaging Sciences, 7(2):1388–1419, 2014.   
+W. Su, S. Boyd, and E. Candes. A differential equation for modeling Nesterov’s accelerated gradi- \` ent method: Theory and insights. In Proc. Advances in Neural Information Processing Systems (NIPS), 2014.   
+E. Ghadimi, H. R. Feyzmahdavian, and M. Johansson. Global convergence of the heavy-ball method for convex optimization. In Proc. European Control Conference (ECC), Linz, Austria, 2015.   
+L. Lessard, B. Recht, and A Packard. Analysis and design of optimization algorithms via integral quadratic constraints. SIAM Journal on Optimization, 26(1):57–95, 2016.   
+T. Yang, Q. Lin, and Z Li. Unified convergence analysis of stochastic momentum methods for convex and non-convex optimization. Preprint available at arXiv:1604.03257v2, 2016.   
+N. Loizou and P. Richtarik. Momentum and stochastic momentum for stochastic gradient, newton, ´ proximal point and subspace descent methods. Preprint available at arXiv:1712.09677v2, 2018.   
+S. Gadat, F. Panloup, and S. Saadane. Stochastic heavy ball. Preprint available at arXiv:1609.04228v2, 2016.   
+R. Kidambi, P. Netrapalli, P. Jain, and S. M. Kakade. On the insufficiency of existing momentum schemes for stochastic optimization. In Proc. International Conference on Learning Representations (ICLR), 2018.   
+Y. Chen, C. Jin, and B. Yu. Stability and convergence trade-off of iterative optimization algorithms. Preprint available at arXiv:1804.01619, 2018.   
+A. Nemirovski and D. B. Yudin. Problem Complexity and Method Efficiency in Optimization. Wiley Interscience, 1983.

parse/train/S1lwRjR9YX/S1lwRjR9YX_content_list.json

@@ -0,0 +1,1295 @@
+[
+    {
+        "type": "text",
+        "text": "STABILITY OF STOCHASTIC GRADIENT METHOD WITH MOMENTUM FOR STRONGLY CONVEX LOSS FUNCTIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            823,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            195,
+            398,
+            223
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            261,
+            544,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "While momentum-based methods, in conjunction with the stochastic gradient descent, are widely used when training machine learning models, there is little theoretical understanding on the generalization error of such methods. In practice, the momentum parameter is often chosen in a heuristic fashion with little theoretical guidance. In this work we use the framework of algorithmic stability to provide an upper-bound on the generalization error for the class of strongly convex loss functions, under mild technical assumptions. Our bound decays to zero inversely with the size of the training set, and increases as the momentum parameter is increased. We also develop an upper-bound on the expected true risk, in terms of the number of training steps, the size of the training set, and the momentum parameter. ",
+        "bbox": [
+            233,
+            292,
+            764,
+            431
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            460,
+            336,
+            477
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A fundamental issue for any machine learning algorithm is its ability to generalize from the training dataset to the test data. A classical framework used to study the generalization error in machine learning is PAC learning (Vapnik and Chervonenkis, 1971; Valiant, 1984). However, the associated bounds using this approach can be conservative. Recently, the notion of uniform stability, introduced in the seminal work of Bousquet and Elisseeff (Bousquet and Elisseef, 2002), is leveraged to analyze the generalization error of the stochastic gradient method (SGM) (Hardt et al., 2016). The result in (Hardt et al., 2016) is a substantial step forward, since SGM is widely used in many practical systems. This method is scalable, robust, and widely adopted in a broad range of problems. ",
+        "bbox": [
+            174,
+            492,
+            825,
+            603
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To accelerate the convergence of SGM, a momentum term is often added in the iterative update of the stochastic gradient (Goodfellow et al., 2016). This approach has a long history, with proven benefits in various settings. The heavy-ball momentum method was first introduced by Polyak (Polyak, 1964), where a weighted version of the previous update is added to the current gradient update. Polyak motivated his method by its resemblance to a heavy ball moving in a potential well defined by the objective function. Momentum methods have been used to accelerate the backpropagation algorithm when training neural networks (Rumelhart et al., 1986). Intuitively, adding momentum accelerates convergence by circumventing sharp curvatures and long ravines of the sublevel sets of the objective function (Wilson et al., 2018). For example, Ochs et al. has presented an illustrative example to show that the momentum can potentially avoid local minima (Ochs et al., 2015). Nesterov has proposed an accelerated gradient method, which converges as $O ( 1 / k ^ { 2 } )$ where $k$ is the number of iterations (Nesterov, 1983). However, the Netstrov momentum does not seem to improve the rate of convergence for stochastic gradient (Goodfellow et al., 2016, Section 8.3.3). In this work, we focus on the heavy-ball momentum. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            804
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Although momentum methods are well known to improve the convergence in SGM, their effect on the generalization error is not well understood. In this work, we first build upon the framework in (Hardt et al., 2016) to obtain a bound on the generalization error of SGM with momentum (SGMM) for the case of strongly convex loss functions. Our bound is independent of the number of training iterations and decreases inversely with the size of the training set. Secondly, we develop an upper-bound on the optimization error, which quantifies the gap between the empirical risk of SGMM and the global optimum. Our bound can be made arbitrarily small by choosing sufficiently many iterations and a sufficiently small learning rate. Finally, we establish an upper-bound on the expected true risk of SGMM as a function of various problem parameters. We note that the class of strongly convex loss functions appears in several important machine learning problems, including linear and logistic regression with a weight decay regularization term. ",
+        "bbox": [
+            174,
+            813,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Other related works: convergence analysis of first order methods with momentum is studied in (Nesterov, 1983; Ochs et al., 2014; Su et al., 2014; Ghadimi et al., 2015; Lessard et al., 2016; Yang et al., 2016; Loizou and Richtarik, 2018; Gadat et al., 2016). Most of these works consider the ´ deterministic setting for gradient update. Only a few works have analyzed the stochastic setting (Yang et al., 2016; Loizou and Richtarik, 2018; Gadat et al., 2016). Our convergence analysis ´ results are not directly comparable with these works due to their different assumptions regarding the properties of loss functions. In particular, we analyze the convergence of SGMM for a smooth and strongly convex loss function as in (Hardt et al., 2016), which is new. ",
+        "bbox": [
+            173,
+            152,
+            825,
+            263
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "First-order methods with noisy gradient are studied in (Kidambi et al., 2018) and references therein. In (Kidambi et al., 2018), the authors show that there exists linear regression problems for which SGM outperforms SGMM in terms of convergence. ",
+        "bbox": [
+            174,
+            271,
+            825,
+            313
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our main focus in this work is on the generalization, and hence true risk, of SGMM. We are aware of only one similar work in this regard, which provides stability bounds for quadratic loss functions (Chen et al., 2018). In this paper, we obtain stability bounds for the general case of strongly convex loss functions. In addition, unlike (Chen et al., 2018), our results show that machine learning models can be trained for multiple epochs of SGMM with bounded generalization errors. ",
+        "bbox": [
+            174,
+            319,
+            825,
+            390
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Notation: We use $\\mathbb { E } [ \\cdot ]$ to denote the expectation and $\\| \\cdot \\|$ to represent the Euclidean norm of a vector. We use lower-case bold font to denote vectors. We use sans-serif font to denote random quantities. Sets and scalars are represented by calligraphic and standard fonts, respectively. ",
+        "bbox": [
+            174,
+            405,
+            825,
+            449
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 GENERALIZATION ERROR AND STABILITY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            469,
+            552,
+            484
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We consider a general supervised learning problem, where $\\boldsymbol { S } = \\{ \\mathbf { z } _ { 1 } , \\cdots , \\mathbf { z } _ { n } \\}$ denotes the set of samples of size $n$ drawn i.i.d. from some space $\\mathcal { Z }$ with an unknown distribution $D$ . We assume a learning model described by parameter vector w. Let $f ( \\mathbf { w } ; \\mathbf { z } )$ denote the loss of the model described by parameter w on example $\\mathbf { z } \\in { \\mathcal { Z } }$ . Our ultimate goal is to minimize the true or population risk: ",
+        "bbox": [
+            174,
+            500,
+            825,
+            558
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f11815991e50be1f7b43d07f22851c346f87887f80156fad39f715d2d8791b5a.jpg",
+        "text": "$$\nR ( \\mathbf { w } ) \\triangleq \\mathbb { E } _ { \\mathbf { z } \\sim D } f ( \\mathbf { w } ; \\mathbf { z } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            564,
+            578,
+            587
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Since the distribution $D$ is unknown, we replace the objective by the empirical risk, i.e., ",
+        "bbox": [
+            171,
+            593,
+            748,
+            608
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bb984ed7d6aa61912ab9b4139b1d7e5a5ed110c4c93ce33ac2894b668679b173.jpg",
+        "text": "$$\nR _ { S } ( \\mathbf { w } ) \\triangleq \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } f ( \\mathbf { w } ; \\mathbf { z } _ { i } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            410,
+            614,
+            588,
+            656
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We assume $\\pmb { w } = A ( \\mathcal { S } )$ for a potentially randomized algorithm $A ( \\cdot )$ . In order to find an upper-bound on the true risk, we consider the generalization error, which is the expected difference of empirical and true risk: ",
+        "bbox": [
+            174,
+            662,
+            823,
+            705
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a8a3a694b8cd23e2b5535e5d79c633f530ab39a9571a79faac9761862b1ed024.jpg",
+        "text": "$$\n\\epsilon _ { g } \\triangleq \\mathbb { E } _ { S , A } [ R ( A ( S ) ) - R _ { S } ( A ( S ) ) ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            710,
+            619,
+            733
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Finally, to upper bound $\\epsilon _ { g }$ , we consider uniform stability: ",
+        "bbox": [
+            173,
+            738,
+            550,
+            755
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Definition 1 Let $s$ and $S ^ { \\prime }$ denote two data sets from space ${ \\mathcal { Z } } ^ { n }$ such that $s$ and $S ^ { \\prime }$ differ in at most one example. Algorithm $A$ is $\\epsilon _ { s }$ -uniformly stable if for all data sets $s , s ^ { \\prime }$ , we have ",
+        "bbox": [
+            169,
+            765,
+            823,
+            795
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6644f44249ed17e0bd4fddfd72b2ca357b70e22916765b5414a1f5987dd396e0.jpg",
+        "text": "$$\n\\operatorname* { s u p } _ { \\mathbf { z } } \\mathbb { E } _ { A } [ f ( A ( { \\cal S } ) ; \\mathbf { z } ) - f ( A ( { \\cal S } ^ { \\prime } ) ; \\mathbf { z } ) ] \\leq \\epsilon _ { s } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            801,
+            635,
+            825
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "It is shown in (Hardt et al., 2016) that uniform stability implies generalization in expectation: ",
+        "bbox": [
+            178,
+            828,
+            782,
+            843
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1 (Hardt et al., 2016) If $A$ is an $\\epsilon _ { s }$ -uniformly stable algorithm, then the generalization error of $A$ is upper-bounded by $\\epsilon _ { s }$ . ",
+        "bbox": [
+            169,
+            854,
+            825,
+            883
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1 shows that it is enough to control the uniform stability of an algorithm to upper bound the generalization error. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 ASSUMPTIONS ON THE LOSS FUNCTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            488,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In our analysis, we will assume that the loss function satisfies the following properties. ",
+        "bbox": [
+            176,
+            128,
+            740,
+            145
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 2 A function $f : \\Psi  \\mathbb { R }$ is $L$ -Lipschitz if for all $\\mathbf { u }$ , $\\mathbf { v } \\in \\Psi$ we have $| f ( \\mathbf { u } ) - f ( \\mathbf { v } ) | \\leq$ $L \\| \\mathbf { u } - \\mathbf { v } \\|$ . ",
+        "bbox": [
+            174,
+            156,
+            823,
+            186
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 3 A function $f : \\Psi  \\mathbb { R }$ is $\\beta$ -smooth if for all $\\mathbf { u }$ , $\\mathbf { v } \\in \\Psi$ we have $\\| \\nabla f ( \\mathbf { u } ) - \\nabla f ( \\mathbf { v } ) \\| \\leq$ $\\beta \\| \\mathbf { u } - \\mathbf { v } \\|$ . ",
+        "bbox": [
+            173,
+            198,
+            825,
+            228
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 4 A function $f : \\Psi  \\mathbb { R }$ is $\\gamma$ -strongly convex if for all $\\mathbf { u }$ , $\\textbf { v } \\in \\ \\Psi$ we have $f ( \\mathbf { u } ) \\geq$ $\\begin{array} { r } { f ( \\mathbf { v } ) + \\nabla f ( \\mathbf { v } ) ^ { \\check { T } } ( \\mathbf { u } - \\mathbf { v } ) + \\frac { \\gamma } { 2 } \\Vert \\mathbf { u } - \\mathbf { v } \\Vert ^ { 2 } } \\end{array}$ . ",
+        "bbox": [
+            171,
+            239,
+            823,
+            271
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We assume that the parameter space $\\Omega$ is a convex set. Furthermore, for the loss function to be $L$ -Lipschitz and and strongly convex, we further assume that $\\Omega$ is compact. Since $\\Omega$ is compact, the SGMM update requires projection. ",
+        "bbox": [
+            174,
+            281,
+            825,
+            324
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 STOCHASTIC GRADIENT METHOD WITH MOMENTUM ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            340,
+            578,
+            356
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The update rule for projected SGMM is given by: ",
+        "bbox": [
+            176,
+            367,
+            500,
+            382
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6be2b41886b403c27ce11fa1c2da5e1c1982e266292e9e0261c6265e30992468.jpg",
+        "text": "$$\n\\mathbf { w } _ { t + 1 } = \\mathbf { P } \\left( \\mathbf { w } _ { t } + \\mu ( \\mathbf { w } _ { t } - \\mathbf { w } _ { t - 1 } ) - \\alpha \\nabla _ { \\mathbf { w } } f ( \\mathbf { w } _ { t } ; \\mathbf { z } _ { \\mathrm { i } _ { t } } ) \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            388,
+            671,
+            415
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { P }$ denotes the Euclidean projection onto $\\Omega$ , $\\alpha > 0$ is the learning rate1, $\\mu > 0$ is the momentum parameter, $\\mathsf { i } _ { t }$ is a randomly selected index, and $f ( \\mathbf { w } _ { t } ; \\mathbf { z } _ { \\mathrm { i } _ { t } } )$ is the loss evaluated on sample $\\mathbf { z } _ { \\mathrm { i } _ { t } }$ . In SGMM, we run the update (5) iteratively for $T$ steps and let ${ \\pmb w } _ { T }$ denote the final output. Note that there are two typical approaches to select $\\mathsf { i } _ { t }$ . The first approach is to select $\\mathsf { i } _ { t } \\in \\{ 1 , \\cdots , n \\}$ uniformly at random at each iteration. The second approach is to permutate $\\{ 1 , \\cdots , n \\}$ randomly once and then select the examples repeatedly in a cyclic manner. Our results are valid for both approaches. The key quantity of interest in this paper is the generalization error for SGMM given by: ",
+        "bbox": [
+            173,
+            421,
+            826,
+            522
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/07815526e545ab9b943635715ecdfc77a0f6431e859aebc379cd2d8b06ea05cc.jpg",
+        "text": "$$\n\\epsilon _ { g } = \\mathbb { E } _ { S , A } [ R ( \\mathbf { w } _ { T } ) - R _ { S } ( \\mathbf { w } _ { T } ) ] = \\mathbb { E } _ { S , \\mathrm { i } _ { 0 } , \\cdots , \\mathrm { i } _ { T - 1 } } [ R ( \\mathbf { w } _ { T } ) - R _ { S } ( \\mathbf { w } _ { T } ) ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            527,
+            722,
+            546
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "since the randomness in $A$ arises from the choice of $\\mathrm { i } _ { 0 } , \\cdots , \\mathrm { i } _ { T - 1 }$ ",
+        "bbox": [
+            173,
+            551,
+            599,
+            566
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 MAIN RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            587,
+            334,
+            603
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the following, we assume that the loss function $f ( \\cdot ; \\mathbf { z } )$ is $\\beta$ -smooth, $L$ -Lipschitz, and $\\gamma$ -strongly convex for all $\\mathbf { z }$ . ",
+        "bbox": [
+            176,
+            617,
+            823,
+            647
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2 (Stability bound) Suppose that the SGMM update (5) is executed for $T$ steps with constant learning rate $\\alpha$ and momentum $\\mu$ . Provided that $\\begin{array} { r } { \\frac { \\alpha \\beta \\gamma } { \\beta + \\gamma } - \\frac { 1 } { 2 } \\leq \\mu < \\frac { \\alpha \\beta \\gamma } { 3 ( \\beta + \\gamma ) } } \\end{array}$ and $\\begin{array} { r } { \\alpha \\le \\frac { 2 } { \\beta + \\gamma } } \\end{array}$ , SGMM satisfies $\\epsilon _ { s }$ -uniform stability where ",
+        "bbox": [
+            173,
+            659,
+            825,
+            707
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/60bef318f53611033075f3b5c83c3e410ddb9230b3f0b57e9f42e0ed05ba908d.jpg",
+        "text": "$$\n\\epsilon _ { s } \\leq \\frac { 2 \\alpha L ^ { 2 } ( \\beta + \\gamma ) } { n \\big ( \\alpha \\beta \\gamma - 3 \\mu ( \\beta + \\gamma ) \\big ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            712,
+            596,
+            750
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The result in Theorem 2 implies that the stability bound decreases inversely with the size of the training set. It increases as the momentum parameter $\\mu$ increases. These properties are also verified in our experimental evaluation. ",
+        "bbox": [
+            173,
+            762,
+            825,
+            805
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3 (Convergence bound) Suppose that the SGMM update (5) is executed for $T$ steps with constant learning rate $\\alpha$ and momentum $\\mu$ . Then we have ",
+        "bbox": [
+            173,
+            818,
+            823,
+            847
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/46bb1616cd06afd1f9ae98b80cb9d213905686f244f94f6dcd8723b02189b33b.jpg",
+        "text": "$$\n\\mathbb { E } _ { S , A } [ R _ { S } ( \\hat { \\mathbf { w } } _ { T } ) - R _ { S } ( \\mathbf { w } _ { S } ^ { * } ) ] \\leq \\frac { \\mu W _ { 0 } } { ( 1 - \\mu ) T } + \\frac { ( 1 - \\mu ) W _ { 1 } } { 2 \\alpha T } - \\frac { \\gamma W _ { 2 } } { 2 } - \\frac { \\mu \\gamma W _ { 3 } } { 2 ( 1 - \\mu ) } + \\frac { \\alpha L ^ { 2 } } { 2 ( 1 - \\mu ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            194,
+            853,
+            782,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\hat { \\mathbf { w } } _ { T }$ denotes the average of $T$ steps of the algorithm, i.e., $\\begin{array} { r } { \\hat { \\mathbf { w } } _ { T } = \\frac { 1 } { T + 1 } \\sum _ { t = 0 } ^ { T } \\mathbf { w } _ { t } } \\end{array}$ , $R _ { S } ( \\mathbf { w } ) =$ $\\begin{array} { r } { \\frac 1 n \\sum _ { i = 1 } ^ { n } f ( \\mathbf { w } ; \\mathbf { z } _ { i } ) , \\mathbf { w } _ { S } ^ { * } = \\arg \\operatorname* { m i n } _ { \\mathbf { w } } R _ { S } ( \\mathbf { w } ) , } \\end{array}$ $W _ { 0 } = \\mathbb { E } _ { S , A } [ R _ { S } ( \\mathbf { w } _ { 0 } ) - R _ { S } ( \\mathbf { w } _ { T } ) ] ,$ , $W _ { 1 } = \\mathbb { E } _ { S , A } [ \\| \\mathbf { w } _ { 0 } -$ $\\pmb { w } _ { S } ^ { * } \\| ^ { 2 } \\|$ , $W _ { 2 } = \\mathbb { E } _ { S , A } [ \\| \\hat { \\mathbf { w } } _ { T } - \\mathbf { w } _ { S } ^ { * } \\| ^ { 2 } ] _ { }$ , and $\\begin{array} { r } { W _ { 3 } = \\frac { 1 } { T + 1 } \\sum _ { t = 0 } ^ { T } \\mathbb { E } _ { S , A } [ \\| \\mathbf { w } _ { t } - \\mathbf { w } _ { t - 1 } \\| ^ { 2 } ] } \\end{array}$ . ",
+        "bbox": [
+            173,
+            99,
+            825,
+            156
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3 bounds the optimization error, i.e., the expected difference between the empirical risk achieved by SGMM and the global minimum. Upon setting $\\mu = 0$ and $\\gamma = 0$ in (7), we can recover the classical bound on optimization error for SGM (Nemirovski and Yudin., 1983), (Hardt et al., 2016, Theorem 5.2). The first two terms in (7) vanish as $T$ increases. The terms with negative sign improve the convergence due to the strongly convexity. The last term depends on the learning rate, $\\alpha$ , the momentum parameter $\\mu$ , and the Lipschitz constant $L$ . This term can be controlled by selecting $\\alpha$ sufficiently small. ",
+        "bbox": [
+            173,
+            166,
+            825,
+            265
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Proposition 1 (Upper-bound on true risk) Suppose that the SGMM update (5) is executed for $T$ steps with constant learning rate $\\alpha$ and momentum $\\mu$ , satisfying the conditions in Theorem 2 and $\\mu ( \\beta + \\gamma ) \\ll \\alpha \\beta \\gamma .$ . Then, setting $\\begin{array} { r } { \\alpha = \\frac { 1 - \\mu } { L } \\sqrt { \\frac { W _ { 1 } } { T } } } \\end{array}$ W1T , we have: ",
+        "bbox": [
+            171,
+            275,
+            825,
+            328
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3522e5e9487403699df7ec94c2df1d4e9ff777a55f20e150e8552c9034b84303.jpg",
+        "text": "$$\n\\mathbb { E } _ { S , A } [ R ( \\hat { \\mathbf { w } } _ { T } ) ] \\leq \\mathbb { E } _ { S , A } [ R _ { S } ( \\mathbf { w } _ { S } ^ { * } ) ] + \\frac { \\mu W _ { 0 } } { ( 1 - \\mu ) T } + L \\sqrt { \\frac { W _ { 1 } } { T } } - \\frac { \\gamma W _ { 2 } } { 2 } - \\frac { \\mu \\gamma W _ { 3 } } { 2 ( 1 - \\mu ) } + \\frac { 2 L ^ { 2 } ( \\beta + \\gamma ) } { n \\beta \\gamma C }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            187,
+            333,
+            805,
+            369
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where C ∆= 1− 3µL(β+γ) T√ and $\\hat { \\mathbf { w } } _ { T }$ as well as the constants $W _ { 0 } , \\cdots , W _ { 3 }$ are defined in Theorem 3. ",
+        "bbox": [
+            174,
+            388,
+            825,
+            412
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Proposition 1 provides a bound on the expected true risk of SGMM in terms of the global minimum of the empirical risk. The bound in (8) is obtained by combining Theorem 2 and Theorem 3 and minimizing the expression over $\\alpha$ . The choice of $\\alpha$ simplifies considerably when $\\mu$ is sufficiently small, as stated in Proposition 1. Due to the page constraint, the proof of this result is provided in the supplementary material. Note that the first two terms in (8) vanish as $T$ increases. The last term in (8) vanishes as the number of samples $n$ increases. ",
+        "bbox": [
+            173,
+            422,
+            825,
+            507
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 PROOF OF THEOREM 2 (STABILITY BOUND) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            526,
+            570,
+            544
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Following (Hardt et al., 2016), we track the divergence of two different iterative sequences of update rules with the same starting point. However, our analysis is more involved as the presence of momentum term requires a more careful bound on the iterative expressions. ",
+        "bbox": [
+            173,
+            558,
+            825,
+            599
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To keep the notation uncluttered, we first consider SGMM without projection and defer the discussion of projection to the end of this proof. Let $S = \\{ \\mathbf { z } _ { 1 } , \\cdots , \\mathbf { z } _ { n } \\}$ and $S ^ { \\prime } = \\{ \\mathbf { z } _ { 1 } ^ { \\prime } , \\cdot \\cdot \\cdot , \\mathbf { z } _ { n } ^ { \\prime } \\}$ be two samples of size $n$ that differ in at most one example. Let ${ \\pmb w } _ { T }$ and ${ \\bf w } _ { T } ^ { \\prime }$ denote the outputs of SGMM on $s$ and $S ^ { \\prime }$ , respectively. We consider the updates $\\mathbf { w } _ { t + 1 } = G _ { t } ( \\mathbf { w } _ { t } ) + \\mu ( \\mathbf { w } _ { t } - \\mathbf { w } _ { t - 1 } )$ and $\\boldsymbol { \\mathsf { w } } _ { t + 1 } ^ { \\prime } =$ $G _ { t } ^ { \\prime } ( \\mathbf { w } _ { t } ^ { \\prime } ) + \\mu ( \\mathbf { w } _ { t } ^ { \\prime } - \\mathbf { w } _ { t - 1 } ^ { \\prime } )$ with $G _ { t } ( \\mathbf { w } _ { t } ) = \\mathbf { w } _ { t } - \\alpha \\nabla _ { \\mathbf { w } } f ( \\dot { \\mathbf { w } } _ { t } ; \\mathbf { z } _ { \\mathrm { i } _ { t } } )$ and $G _ { t } ^ { \\prime } ( \\mathbf { w } _ { t } ^ { \\prime } ) = \\mathbf { w } _ { t } ^ { \\prime } - \\alpha \\nabla _ { \\mathbf { w } } f ( \\mathbf { w } _ { t } ^ { \\prime } ; \\mathbf { z } _ { \\mathfrak { i } _ { t } } ^ { \\prime } )$ , respectively, for $t = 1 , \\cdots , T$ . We denote $\\delta _ { t } \\triangleq \\Vert \\mathbf { w } _ { t } - \\mathbf { w } _ { t } ^ { \\prime } \\Vert$ . Suppose $\\pmb { w } _ { 0 } = \\pmb { w } _ { 0 } ^ { \\prime }$ , i.e., $\\delta _ { 0 } = 0$ . We first establish an upper-bound on $\\mathbb { E } _ { A } [ \\delta _ { t + 1 } ]$ in terms of $\\mathbb { E } _ { A } [ \\delta _ { t } ]$ and $\\mathbb { E } _ { A } [ \\delta _ { t - 1 } ]$ in the following lemma, whose proof is provided in the supplementary document. ",
+        "bbox": [
+            173,
+            606,
+            826,
+            726
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Lemma 1 Provided that $\\begin{array} { r } { \\alpha \\leq \\frac { 2 } { \\beta + \\gamma } } \\end{array}$ , an upper-bound on $\\mathbb { E } _ { A } [ \\delta _ { t + 1 } ]$ is given by ",
+        "bbox": [
+            173,
+            734,
+            676,
+            753
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/63a028368460375d017c2eec115cf4969acdb03fbb026e15ede771435af1b54b.jpg",
+        "text": "$$\n\\mathbb { E } _ { A } [ \\delta _ { t + 1 } ] \\leq \\Big ( 1 + \\mu - \\frac { \\alpha \\beta \\gamma } { \\beta + \\gamma } \\Big ) \\mathbb { E } _ { A } [ \\delta _ { t } ] + \\mu \\mathbb { E } _ { A } [ \\delta _ { t - 1 } ] + \\frac { 2 \\alpha L } { n } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            299,
+            758,
+            699,
+            791
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Using the result of Lemma 1, in the following, we develop an upper bound on $\\mathbb { E } _ { A } [ \\delta _ { T } ]$ . Let us consider the recursion ",
+        "bbox": [
+            171,
+            801,
+            825,
+            830
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1ec757026eb6b5c0dbfcbcfa1fa35e98deaa3e4a201931ef7d2eeb2941e4f955.jpg",
+        "text": "$$\n\\mathbb { E } _ { A } [ \\tilde { \\delta } _ { t + 1 } ] = \\Big ( 1 + \\mu - \\frac { \\alpha \\beta \\gamma } { \\beta + \\gamma } \\Big ) \\mathbb { E } _ { A } [ \\tilde { \\delta } _ { t } ] + \\mu \\mathbb { E } _ { A } [ \\tilde { \\delta } _ { t - 1 } ] + \\frac { 2 \\alpha L } { n }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            832,
+            697,
+            864
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "with $\\tilde { \\delta } _ { 0 } = \\delta _ { 0 } = 0$ . Upon inspecting (10) it is clear that ",
+        "bbox": [
+            174,
+            869,
+            531,
+            886
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ca35d49ed3fde426fc9a073128fb2e48a0eaaf72d3c639926db621c250da0ee6.jpg",
+        "text": "$$\n\\mathbb { E } _ { A } [ \\tilde { \\delta } _ { t } ] \\geq \\big ( 1 + \\mu - \\frac { \\alpha \\beta \\gamma } { \\beta + \\gamma } \\big ) \\mathbb { E } _ { A } [ \\tilde { \\delta } _ { t - 1 } ] , \\qquad \\forall t \\geq 1 ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            888,
+            665,
+            922
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "as we simply drop the remainder of positive terms. Substituting (11) into (10), we have ",
+        "bbox": [
+            173,
+            102,
+            743,
+            119
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/32311ec90f44585cc3c554ff36f063af12a9ea3d9b95054a2799526da95acc3d.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\mathbb { E } _ { A } [ \\tilde { \\delta } _ { t + 1 } ] \\leq \\Big ( 1 + \\mu + \\frac { \\mu } { 1 + \\mu - \\frac { \\alpha \\beta \\gamma } { \\beta + \\gamma } } - \\frac { \\alpha \\beta \\gamma } { \\beta + \\gamma } \\Big ) \\mathbb { E } _ { A } [ \\tilde { \\delta } _ { t } ] + \\frac { 2 \\alpha L } { n } } \\\\ { \\displaystyle \\qquad \\leq \\Big ( 1 + 3 \\mu - \\frac { \\alpha \\beta \\gamma } { \\beta + \\gamma } \\Big ) \\mathbb { E } _ { A } [ \\tilde { \\delta } _ { t } ] + \\frac { 2 \\alpha L } { n } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            121,
+            707,
+            193
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$\\begin{array} { r } { \\mu \\geq \\frac { \\alpha \\beta \\gamma } { \\beta + \\gamma } - \\frac { 1 } { 2 } } \\end{array}$ ",
+        "bbox": [
+            173,
+            195,
+            542,
+            214
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Noting that $\\mathbb { E } _ { A } [ \\tilde { \\delta } _ { t } ] \\geq \\mathbb { E } _ { A } [ \\delta _ { t } ]$ for all $t$ including $T$ , we have ",
+        "bbox": [
+            173,
+            222,
+            560,
+            239
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/43a0a249a7620e8d06804649e98805839c5da54402019943cbdcf62a92d2b56c.jpg",
+        "text": "$$\n\\mathbb { E } _ { A } [ \\delta _ { T } ] \\le \\frac { 2 \\alpha L } { n } \\sum _ { t = 1 } ^ { T } \\Big ( 1 + 3 \\mu - \\frac { \\alpha \\beta \\gamma } { \\beta + \\gamma } \\Big ) ^ { t } \\le \\frac { 2 \\alpha L ( \\beta + \\gamma ) } { n \\big ( \\alpha \\beta \\gamma - 3 \\mu ( \\beta + \\gamma ) \\big ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            277,
+            241,
+            720,
+            284
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where the second expression holds since 0 ≤ µ < αβγ3(β+γ) is assumed. ",
+        "bbox": [
+            176,
+            287,
+            630,
+            308
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Applying the $L$ -Lipschitz property on $f ( \\cdot , \\mathbf { z } )$ , it follows that ",
+        "bbox": [
+            173,
+            313,
+            568,
+            329
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/671e73e560a18bb3902dd8b953102d3d233455dfe1fa457016f3513090d86cf1.jpg",
+        "text": "$$\n\\mathbb { E } _ { A } [ | f ( \\mathbf { w } _ { T } ; \\mathbf { z } ) - f ( \\mathbf { w } _ { T } ^ { \\prime } ; \\mathbf { z } ) | ] \\leq L \\mathbb { E } _ { A } [ \\delta _ { T } ] \\leq \\frac { 2 \\alpha L ^ { 2 } ( \\beta + \\gamma ) } { n \\big ( \\alpha \\beta \\gamma - 3 \\mu ( \\beta + \\gamma ) \\big ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            279,
+            349,
+            718,
+            386
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Since this bound holds for all $s , s ^ { \\prime }$ and $\\mathbf { z }$ , we obtain an upper-bound on the uniform stability and the proof is complete. Our stability bound in Theorem 2 holds for the projected SGMM update (5) because Euclidean projection does not increase the distance between projected points (the argument is essentially analogous to (Hardt et al., 2016, Lemma 4.6)). In particular, note that Lemma 1 holds for the projected SGMM. ",
+        "bbox": [
+            173,
+            388,
+            826,
+            459
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 PROOF OF THEOREM 3 (CONVERGENCE BOUND) ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            477,
+            611,
+            494
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Again, we first consider SGMM without projection and discuss the extension to projection at the end of this proof. Our proof is inspired by the convergence analysis in (Yang et al., 2016; Ghadimi et al., 2015) for a convex loss function with bounded variance and time-decaying learning rate. Different from these works, we analyze the convergence of SGMM for a smooth and strongly convex loss function with constant learning rate. To facilitate the convergence analysis, we define: ",
+        "bbox": [
+            173,
+            508,
+            825,
+            579
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fc228db5ffee619861c5c22295c28a13f616348f73dad1e6fd68672a7424c28f.jpg",
+        "text": "$$\n\\mathbf p _ { t } \\triangleq \\frac { \\mu } { 1 - \\mu } ( \\mathbf w _ { t } - \\mathbf w _ { t - 1 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            582,
+            583,
+            611
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "with $\\pmb { \\mathrm { p } } _ { 0 } = 0$ . Substituting into the SGMM update, the parameter recursion is given by ",
+        "bbox": [
+            174,
+            612,
+            735,
+            627
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d01442593d5703f5c4fe73e5eeea06dbc65b707bba0246fb18bea2e121a0ab61.jpg",
+        "text": "$$\n\\mathbf { w } _ { t + 1 } + \\mathbf { p } _ { t + 1 } = \\mathbf { w } _ { t } + \\mathbf { p } _ { t } - { \\frac { \\alpha } { 1 - \\mu } } \\nabla _ { \\mathbf { w } } f ( \\mathbf { w } _ { t } ; \\mathbf { z } _ { \\mathrm { i } _ { t } } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            630,
+            656,
+            660
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "It follows that ",
+        "bbox": [
+            173,
+            661,
+            267,
+            675
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4c79724b3f08e46e78cd07f5e58308d3613bedcd9964f52f2c621f8670cf939b.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\| { \\bf w } _ { t + 1 } + { \\bf p } _ { t + 1 } - { \\bf w } \\| ^ { 2 } = \\| { \\bf w } _ { t } + { \\bf p } _ { t } - { \\bf w } \\| ^ { 2 } + \\big ( \\frac { \\alpha } { 1 - \\mu } \\big ) ^ { 2 } \\| \\nabla _ { { \\bf w } } f ( { \\bf w } _ { t } ; { \\bf z } _ { \\mathrm { i } _ { t } } ) \\| ^ { 2 } } \\\\ { \\displaystyle \\qquad - \\frac { 2 \\alpha } { 1 - \\mu } ( { \\bf w } _ { t } + { \\bf p } _ { t } - { \\bf w } ) ^ { T } \\nabla _ { { \\bf w } } f ( { \\bf w } _ { t } ; { \\bf z } _ { \\mathrm { i } _ { t } } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            261,
+            675,
+            735,
+            739
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Substituting $\\mathbf { p } _ { t }$ (15) into (17), the recursion (16) can be written as ",
+        "bbox": [
+            174,
+            746,
+            606,
+            762
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/79a202f4fcadbac35e2f4a4e8c4bfa68145475244db841bcc1743c8f3350041f.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle { \\bf w } _ { t + 1 } + { \\bf p } _ { t + 1 } - { \\bf w } \\| ^ { 2 } = \\| { \\bf w } _ { t } + { \\bf p } _ { t } - { \\bf w } \\| ^ { 2 } + \\big ( \\frac { \\alpha } { 1 - \\mu } \\big ) ^ { 2 } \\| \\nabla _ { { \\bf w } } f ( { \\bf w } _ { t } ; { \\bf z } _ { { \\bf i } _ { t } } ) \\| ^ { 2 } } \\ ~ } \\\\ { { \\displaystyle \\phantom { \\frac { 1 } { 1 + \\mu } } - \\frac { 2 \\alpha \\mu } { ( 1 - \\mu ) ^ { 2 } } ( { \\bf w } _ { t } - { \\bf w } _ { t - 1 } ) ^ { T } \\nabla _ { { \\bf w } } f ( { \\bf w } _ { t } ; { \\bf z } _ { { \\bf i } _ { t } } ) - \\frac { 2 \\alpha } { 1 - \\mu } ( { \\bf w } _ { t } - { \\bf w } ) ^ { T } \\nabla _ { { \\bf w } } f ( { \\bf w } _ { t } ; { \\bf z } _ { { \\bf i } _ { t } } ) } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            763,
+            838,
+            828
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Upon taking the expectation with respect to $\\mathsf { i } _ { t }$ in (18) we have ",
+        "bbox": [
+            171,
+            843,
+            581,
+            859
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c254a13f5a65c006d889aca7c47a0e82edae34c64500abbc0f1e2df489ff80a6.jpg",
+        "text": "$$\n\\begin{array} { c } { \\displaystyle \\mathfrak { l } _ { t } \\| \\mathbf { w } _ { t + 1 } + \\mathbf { p } _ { t + 1 } - \\mathbf { w } \\| ^ { 2 } \\leq \\| \\mathbf { w } _ { t } + \\mathbf { p } _ { t } - \\mathbf { w } \\| ^ { 2 } + \\big ( \\displaystyle \\frac { \\alpha } { 1 - \\mu } \\big ) ^ { 2 } L ^ { 2 } - \\displaystyle \\frac { 2 \\alpha \\mu } { ( 1 - \\mu ) ^ { 2 } } \\big ( \\mathbf { w } _ { t } - \\mathbf { w } _ { t - 1 } \\big ) ^ { T } \\nabla _ { \\mathbf { w } } R _ { S } ( \\mathbf { w } _ { t } ) } \\\\ { \\displaystyle - \\displaystyle \\frac { 2 \\alpha } { 1 - \\mu } ( \\mathbf { w } _ { t } - \\mathbf { w } ) ^ { T } \\nabla _ { \\mathbf { w } } R _ { S } ( \\mathbf { w } _ { t } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            861,
+            830,
+            929
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where we use the fact that $\\left\\| \\nabla _ { \\mathbf { w } } f ( \\mathbf { w } _ { t } ; \\mathbf { z } _ { \\mathsf { i } _ { t } } ) \\right\\| \\leq L$ , due to $L$ -Lipschitz, and that $\\mathbb { E } _ { \\mathbf { i } _ { t } } [ \\nabla _ { \\mathbf { w } } f ( \\mathbf { w } _ { t } ; \\mathbf { z } _ { \\mathbf { i } _ { t } } ) ] =$ $\\nabla _ { \\mathbf { w } } R _ { S } ( \\mathbf { w } _ { t } )$ . Furthermore, since $R _ { S } ( \\cdot )$ is a $\\gamma$ -strongly convex function, for all $\\mathbf { w } _ { t }$ and $\\mathbf { w } _ { t - 1 }$ , we have ",
+        "bbox": [
+            173,
+            102,
+            828,
+            145
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a2b30a8c1a9b1535ed3e9d3e753b00b1ba0a6cca35a5024c2d0ea904215a5741.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\quad ( \\mathbf { w } _ { t } - \\mathbf { w } ) ^ { T } \\nabla _ { \\mathbf { w } } R _ { S } ( \\mathbf { w } _ { t } ) \\geq R _ { S } ( \\mathbf { w } _ { t } ) - R _ { S } ( \\mathbf { w } ) + \\displaystyle \\frac { \\gamma } { 2 } \\| \\mathbf { w } _ { t } - \\mathbf { w } \\| ^ { 2 } , } \\\\ & { \\quad ( \\mathbf { w } _ { t } - \\mathbf { w } _ { t - 1 } ) ^ { T } \\nabla _ { \\mathbf { w } } R _ { S } ( \\mathbf { w } _ { t } ) \\geq R _ { S } ( \\mathbf { w } _ { t } ) - R _ { S } ( \\mathbf { w } _ { t - 1 } ) + \\displaystyle \\frac { \\gamma } { 2 } \\| \\mathbf { w } _ { t } - \\mathbf { w } _ { t - 1 } \\| ^ { 2 } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            254,
+            145,
+            741,
+            203
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Substituting (20) in (19), we have ",
+        "bbox": [
+            173,
+            209,
+            397,
+            224
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ca234c10d7a9a98c96e9baa291c7e704e3400cc0db0c27b55ab2a08c7d7df87f.jpg",
+        "text": "$$\n\\begin{array} { r } { \\displaystyle \\mathfrak { L } _ { i _ { t } } \\big [ | \\mathbf { w } _ { t + 1 } + \\mathbf { p } _ { t + 1 } - \\mathbf { w } | ^ { 2 } \\big ] \\leq \\| \\mathbf { w } _ { t } + \\mathbf { p } _ { t } - \\mathbf { w } \\| ^ { 2 } - \\frac { \\alpha \\gamma } { 1 - \\mu } \\| \\mathbf { w } _ { t } - \\mathbf { w } \\| ^ { 2 } - \\frac { 2 \\alpha \\mu } { ( 1 - \\mu ) ^ { 2 } } \\big ( R _ { S } ( \\mathbf { w } _ { t } ) - R _ { S } ( \\mathbf { w } _ { t - 1 } ) } \\\\ { \\displaystyle - \\frac { 2 \\alpha } { 1 - \\mu } \\big ( R _ { S } ( \\mathbf { w } _ { t } ) - R _ { S } ( \\mathbf { w } ) \\big ) + \\frac { \\alpha ^ { 2 } L ^ { 2 } } { ( 1 - \\mu ) ^ { 2 } } - \\frac { \\alpha \\mu \\gamma } { ( 1 - \\mu ) ^ { 2 } } \\| \\mathbf { w } _ { t } - \\mathbf { w } _ { t - 1 } \\| ^ { 2 } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            226,
+            839,
+            297
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Taking expectation over $\\mathrm { i } _ { 0 } , \\cdots , \\mathrm { i } _ { t }$ for a given $s$ , summing (21) for $t = 0 , \\cdots , T$ , and rearranging terms, we have ",
+        "bbox": [
+            171,
+            318,
+            826,
+            348
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2c528b7c8220125fd29f48346594af296e90ee326e21a4db2d2512a7b4a1d554.jpg",
+        "text": "$$\n\\begin{array} { r l r } {  { \\frac { 2 \\alpha } { 1 - \\mu } \\sum _ { t = 0 } ^ { T } \\mathbb { E } _ { A } \\big [ R _ { S } ( \\mathbf { w } _ { t } ) - R _ { S } ( \\mathbf { w } ) \\big ] \\leq \\frac { 2 \\alpha \\mu } { ( 1 - \\mu ) ^ { 2 } } \\mathbb { E } _ { A } \\big [ R _ { S } ( \\mathbf { w } _ { 0 } ) - R _ { S } ( \\mathbf { w } _ { T } ) \\big ] - \\frac { \\alpha \\gamma } { 1 - \\mu } \\sum _ { t = 0 } ^ { T } \\mathbb { E } _ { A } \\big [ \\| \\mathbf { w } _ { t } - \\mathbf { w } \\| ^ { 2 } \\big ] } } \\\\ & { } & { \\qquad - \\frac { \\alpha \\mu \\gamma } { ( 1 - \\mu ) ^ { 2 } } \\sum _ { t = 0 } ^ { T } \\mathbb { E } _ { A } \\big [ \\| \\mathbf { w } _ { t } - \\mathbf { w } _ { t - 1 } \\| ^ { 2 } \\big ] + \\mathbb { E } _ { A } \\big [ \\| \\mathbf { w } _ { 0 } - \\mathbf { w } \\| ^ { 2 } \\big ] + \\frac { \\alpha ^ { 2 } L ^ { 2 } ( T + 1 ) } { ( 1 - \\mu ) ^ { 2 } } . \\qquad ( 2 2 ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            348,
+            839,
+            436
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Since $\\| \\cdot \\|$ is a convex function, for all $\\mathbf { w } _ { T }$ and w, we have ",
+        "bbox": [
+            173,
+            439,
+            563,
+            454
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/69921eed00a190b0a9ef7a311156336f4f5cc3a570361c44dae75ec523f56137.jpg",
+        "text": "$$\n\\| \\hat { \\mathbf { w } } _ { T } - \\mathbf { w } \\| ^ { 2 } \\leq \\frac { 1 } { T + 1 } \\sum _ { t = 0 } ^ { T } \\| \\mathbf { w } _ { t } - \\mathbf { w } \\| ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            455,
+            629,
+            500
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, due to convexity of $R _ { S } ( \\cdot )$ , we have ",
+        "bbox": [
+            173,
+            508,
+            496,
+            525
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/639c8f12a304f926a67d3cb01eb2fee31b1f875e1efd3d82eb51338e59dc5472.jpg",
+        "text": "$$\nR _ { S } ( \\hat { \\mathbf { w } } _ { T } ) - R _ { S } ( \\mathbf { w } ) \\leq \\frac { 1 } { T + 1 } \\sum _ { t = 0 } ^ { T } \\big ( R _ { S } ( \\mathbf { w } _ { t } ) - R _ { S } ( \\mathbf { w } ) \\big ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            315,
+            526,
+            681,
+            570
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Taking expectation over $s$ , applying inequalities (23) and (24) into (22), and substituting $\\mathbf { w } = \\mathbf { w } _ { S } ^ { * }$ , we obtain (7) and the proof is complete. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            601
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our convergence bound in Theorem 3 can be extended to projected SGMM (5). Let use denote 1 ∆= wt + µ(wt − wt−1) − α∇wf (wt; zit ). Then, for any feasible w ∈ Ω, (17) holds for yt+1, i.e., ",
+        "bbox": [
+            174,
+            606,
+            825,
+            655
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a2ba4b84de89521ee7abc0b91bff08d231706bd8898e43a6a31eab60b142e218.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\| { \\bf y } _ { t + 1 } + \\frac { \\mu } { 1 - \\mu } ( { \\bf y } _ { t + 1 } - { \\bf w } _ { t } ) - { \\bf w } \\| ^ { 2 } = \\| { \\bf w } _ { t } + { \\bf p } _ { t } - { \\bf w } \\| ^ { 2 } + \\big ( \\frac { \\alpha } { 1 - \\mu } \\big ) ^ { 2 } \\| \\nabla _ { \\bf w } f ( { \\bf w } _ { t } ; { \\bf z } _ { \\mathrm { i } _ { t } } ) \\| ^ { 2 } } \\\\ { \\displaystyle - \\frac { 2 \\alpha } { 1 - \\mu } ( { \\bf w } _ { t } + { \\bf p } _ { t } - { \\bf w } ) ^ { T } \\nabla _ { \\bf w } f ( { \\bf w } _ { t } ; { \\bf z } _ { \\mathrm { i } _ { t } } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            217,
+            674,
+            779,
+            739
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Note that the LHS of (25) can be written as ",
+        "bbox": [
+            174,
+            746,
+            459,
+            762
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d4d34dcf8cc714b32df7a88d01db747b12788818a7160beaf27e6d8816245d3a.jpg",
+        "text": "$$\n\\| { \\bf y } _ { t + 1 } + \\frac { \\mu } { 1 - \\mu } ( { \\bf y } _ { t + 1 } - { \\bf w } _ { t } ) - { \\bf w } \\| ^ { 2 } = \\frac { 1 } { 1 - \\mu } \\| { \\bf y } _ { t + 1 } - \\left( \\mu { \\bf w } _ { t } + ( 1 - \\mu ) { \\bf w } \\right) \\| .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            250,
+            781,
+            746,
+            814
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We note that $\\mu \\mathbf { w } _ { t } + ( 1 - \\mu ) \\mathbf { w } \\in \\Omega$ for any $\\mathbf { w } \\in \\Omega$ and $\\boldsymbol { \\mathsf { w } } _ { t } \\in \\Omega$ since $\\Omega$ is convex. ",
+        "bbox": [
+            173,
+            816,
+            710,
+            832
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Now in projected SGMM, we have ",
+        "bbox": [
+            174,
+            838,
+            405,
+            853
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e8f324ad1ed4067ad0515f702e42d3fe4c2e92058b1ad836e2294b9282b313e4.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\| \\mathbf { w } _ { t + 1 } - \\big ( \\mu \\mathbf { w } _ { t } + ( 1 - \\mu ) \\mathbf { w } \\big ) \\| ^ { 2 } = \\| \\mathbf { P } ( \\mathbf { y } _ { t + 1 } ) - \\big ( \\mu \\mathbf { w } _ { t } + ( 1 - \\mu ) \\mathbf { w } \\big ) \\| ^ { 2 } } \\\\ & { \\qquad \\leq \\| \\mathbf { y } _ { t + 1 } - \\big ( \\mu \\mathbf { w } _ { t } + ( 1 - \\mu ) \\mathbf { w } \\big ) \\| ^ { 2 } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            269,
+            853,
+            728,
+            895
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "since projection a point onto $\\Omega$ moves it closer to any point in $\\Omega$ . This shows inequality (19) holds, and the convergence results do not change. ",
+        "bbox": [
+            176,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/994112fa98c557084cc8d4db0f0317d8f5bc957f66c54c3ce88a4f49e9a50774.jpg",
+        "image_caption": [
+            "Figure 1: Generalization performance (cross entropy) of logistic regression for notMNIST dataset with $T = 1 0 0 0$ iterations and minibatch size 10. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            106,
+            781,
+            270
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/3e79fc910d33315a92ac80f4e92d5f92a2a5a1c06dff17ec37a97d199ab63f73.jpg",
+        "image_caption": [
+            "Figure 2: Generalization performance (classification accuracy) of logistic regression for notMNIST dataset with $T = 1 0 0 0$ iterations and minibatch size 10. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            333,
+            781,
+            508
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6 EXPERIMENTAL EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            578,
+            449,
+            593
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we validate the insights obtained in our theoretical results in experimental evaluation. Our main goal is to study how adding momentum affects the convergence and generalization of SGM. We study the performance of SGMM when applied to the notMINIST dataset. Please note that similar results are provided for the MNIST dataset in the supplementary document. We train a logistic regression model with the weight decay regularization using SGMM for binary classification on the two-class notMNIST dataset that contains the images from letter classes “C” and “J”, which leads to a smooth and strongly convex loss function. We set the learning rate $\\alpha = 0 . 0 1$ . The weight decay coefficient and the minibatch size are set to 0.001 and 10, respectively. We use 100 SGMM realizations to evaluate the average performance. We compare the training and generalization performance of SGM without momentum with that of SGMM under $\\mu = 0 . 5$ and $\\mu = 0 . 9$ , which are common momentum values used in practice (Goodfellow et al., 2016, Section 8.3.2). ",
+        "bbox": [
+            174,
+            611,
+            825,
+            763
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The generalization error (with respect to cross entropy) and training error versus the number of training samples, $n$ , under SGMM with fixed $T = 1 0 0 0$ iterations are shown in Figures 1a and 1b, respectively, for $\\mu = 0 , 0 . 5 , 0 . 9$ . In Figures 2a and 2b, we plot the generalization error (with respect to classification accuracy) and the training accuracy as a function of the number of training samples for the same dataset. First, we observe that the generalization error (with respect to both cross entropy and classification accuracy) decreases as $n$ increases for all values of $\\mu$ , which is suggested by our stability upper-bound in Theorem 2. In addition, for sufficiently large $n$ , we observe that the generalization error increases with $\\mu$ , consistent with Theorem 2. On the other hand, the training error increases as $n$ increases, which is expected. We can observe that adding momentum reduces training error as it improves the convergence rate. The training accuracy also improves by adding momentum as illustrated in Fig. 2b. ",
+        "bbox": [
+            174,
+            771,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/cdbcbe27e7037e8c104271d33ddc10a05d31f9a3ea6f70372dd14653bc1002b7.jpg",
+        "image_caption": [
+            "Figure 3: Training and test error of logistic regression (cross entropy loss) for notMNIST dataset with $n = 5 0 0$ training samples and minibatch size 10. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            106,
+            781,
+            268
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/096173fc5eb627de5b927381f209c0dbad50fd8f4ce7f7c7d226702b3b0499e2.jpg",
+        "image_caption": [
+            "Figure 4: Training and test accuracy of logistic regression for notMNIST dataset with $n = 5 0 0$ training samples and minibatch size 10. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            329,
+            781,
+            493
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In order to study the optimization error of SGMM, we show the training error and test error versus the number of epochs, under SGMM trained with $n = 5 0 0$ samples in Figures 3a and 3b, respectively. We plot the classification accuracy for training and test datasets in Figures 4a and 4b, respectively. We observe that the training error decreases as the number of epochs increases for all values of $\\mu$ , which is consistent with the convergence analysis in Theorem 3. Furthermore, as expected, we see that adding momentum improves the training error and accuracy. However, as the number of epochs increases, we note that the benefit of momentum on the test error and accuracy becomes negligible. This happens because adding momentum also results in a higher generalization error thus penalizing the gain in training error. ",
+        "bbox": [
+            174,
+            563,
+            825,
+            688
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            710,
+            328,
+            726
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We study the generalization error and convergence of SGMM for the class of strongly convex loss functions, under mild technical conditions. We establish an upper-bound on the generalization error, which decreases with the size of the training set, and increases as the momentum parameter is increased. Secondly, we analyze the convergence of SGMM during training, by establishing an upper-bound on the gap between the empirical risk of SGMM and the global minimum. Our proposed bound reduces to a classical bound on the optimization error of SGM (Nemirovski and Yudin., 1983) for convex functions, when the momentum parameter is set to zero. Finally, we establish an upper-bound on the expected difference between the true risk of SGMM and the global minimum of the empirical risk, and illustrate how it scales with the number of training steps and the size of the training set. Although our results are established for the case when the learning rate is constant, they can be easily extended to the case when the learning rate decreases with the number of iterations. We also present experimental evaluations on the notMNIST dataset and show that the numerical plots are consistent with our theoretical bounds on the generalization error and the convergence gap. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES   \nV. N. Vapnik and A. Y. Chervonenkis. On the uniform convergence of relative frequencies of events to their probabilities. Theory of Probability and Its Applications, 16(2):264–280, 1971.   \nL. G. Valiant. A theory of the learnable. Communications of the ACM, 27(11):1134–1142, 1984.   \nO. Bousquet and A. Elisseef. Stability and generalization. Journal of Machine Learning Research, 2:499–526, 2002.   \nM. Hardt, B. Recht, and Y Singer. Train faster, generalize better: Stability of stochastic gradient descent. Preprint available at arXiv:1509.01240v2, 2016.   \nI. Goodfellow, Y. Bengio, and A. Courville. Deep Learning. Cambridge, USA: The MIT Press, 2016.   \nB. T. Polyak. Some methods of speeding up the convergence of iteration methods. USSR Computational Mathematics and Mathematical Physics, 4(5):1–17, 1964.   \nD. E. Rumelhart, G. E. Hinton, and R. J. Williams. Learning representations by backpropagating errors. Nature, 323:533–536, 1986.   \nA. C. Wilson, B. Recht, and M. I. Jordan. A lyapunov analysis of momentum methods in optimization. Preprint available at arXiv:1611.02635v4, 2018.   \nP. Ochs, T. Brox, and T. Pock. IPIASCO: Inertial proximal algorithm for strongly convex optimization. Journal of Mathematical Imaging and Vision, 53(2):171–181, 2015.   \nY. Nesterov. A method of solving a convex programming problem with convergence $O ( 1 / k ^ { 2 } )$ . Soviet Mathematics Doklady, 27(2):372–376, 1983.   \nP. Ochs, Y. Chen, T. Brox, and T. Pock. IPIANO: Inertial proximal algorithm for nonconvex optimization. SIAM Journal on Imaging Sciences, 7(2):1388–1419, 2014.   \nW. Su, S. Boyd, and E. Candes. A differential equation for modeling Nesterov’s accelerated gradi- \\` ent method: Theory and insights. In Proc. Advances in Neural Information Processing Systems (NIPS), 2014.   \nE. Ghadimi, H. R. Feyzmahdavian, and M. Johansson. Global convergence of the heavy-ball method for convex optimization. In Proc. European Control Conference (ECC), Linz, Austria, 2015.   \nL. Lessard, B. Recht, and A Packard. Analysis and design of optimization algorithms via integral quadratic constraints. SIAM Journal on Optimization, 26(1):57–95, 2016.   \nT. Yang, Q. Lin, and Z Li. Unified convergence analysis of stochastic momentum methods for convex and non-convex optimization. Preprint available at arXiv:1604.03257v2, 2016.   \nN. Loizou and P. Richtarik. Momentum and stochastic momentum for stochastic gradient, newton, ´ proximal point and subspace descent methods. Preprint available at arXiv:1712.09677v2, 2018.   \nS. Gadat, F. Panloup, and S. Saadane. Stochastic heavy ball. Preprint available at arXiv:1609.04228v2, 2016.   \nR. Kidambi, P. Netrapalli, P. Jain, and S. M. Kakade. On the insufficiency of existing momentum schemes for stochastic optimization. In Proc. International Conference on Learning Representations (ICLR), 2018.   \nY. Chen, C. Jin, and B. Yu. Stability and convergence trade-off of iterative optimization algorithms. Preprint available at arXiv:1804.01619, 2018.   \nA. Nemirovski and D. B. Yudin. Problem Complexity and Method Efficiency in Optimization. Wiley Interscience, 1983. ",
+        "bbox": [
+            169,
+            70,
+            828,
+            892
+        ],
+        "page_idx": 8
+    }
+]

parse/train/SkzK4iC5Ym/SkzK4iC5Ym.md

@@ -0,0 +1,916 @@
+# DIMINISHING BATCH NORMALIZATION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+In this paper, we propose a generalization of the BN algorithm, diminishing batch normalization (DBN), where we update the BN parameters in a diminishing moving average way. Batch normalization (BN) is very effective in accelerating the convergence of a neural network training phase that it has become a common practice. Our proposed DBN algorithm remains the overall structure of the original BN algorithm while introduces a weighted averaging update to some trainable parameters. We provide an analysis of the convergence of the DBN algorithm that converges to a stationary point with respect to trainable parameters. Our analysis can be easily generalized for original BN algorithm by setting some parameters to constant. To the best knowledge of authors, this analysis is the first of its kind for convergence with Batch Normalization introduced. We analyze a two-layer model with arbitrary activation function. The primary challenge of the analysis is the fact that some parameters are updated by gradient while others are not. The convergence analysis applies to any activation function that satisfies our common assumptions. For the analysis, we also show the sufficient and necessary conditions for the stepsizes and diminishing weights to ensure the convergence. In the numerical experiments, we use more complex models with more layers and ReLU activation. We observe that DBN outperforms the original BN algorithm on Imagenet, MNIST, NI and CIFAR-10 datasets with reasonable complex FNN and CNN models.
+
+# 1 INTRODUCTION
+
+Deep neural networks (DNN) have shown unprecedented success in various applications such as object detection. However, it still takes a long time to train a DNN until it converges. Ioffe & Szegedy identified a critical problem involved in training deep networks, internal covariate shift, and then proposed batch normalization (BN) to decrease this phenomenon. BN addresses this problem by normalizing the distribution of every hidden layer’s input. In order to do so, it calculates the preactivation mean and standard deviation using mini-batch statistics at each iteration of training and uses these estimates to normalize the input to the next layer. The output of a layer is normalized by using the batch statistics, and two new trainable parameters per neuron are introduced that capture the inverse operation. It is now a standard practice Bottou et al. (2016); He et al. (2016). While this approach leads to a significant performance jump, to the best of our knowledge, there is no known theoretical guarantee for the convergence of an algorithm with BN. The difficulty of analyzing the convergence of the BN algorithm comes from the fact that not all of the BN parameters are updated by gradients. Thus, it invalidates most of the classical studies of convergence for gradient methods.
+
+In this paper, we propose a generalization of the BN algorithm, diminishing batch normalization (DBN), where we update the BN parameters in a diminishing moving average way. It essentially means that the BN layer adjusts its output according to all past mini-batches instead of only the current one. It helps to reduce the problem of the original BN that the output of a BN layer on a particular training pattern depends on the other patterns in the current mini-batch, which is pointed out by Bottou et al.. By setting the layer parameter we introduce into DBN to a specific value, we recover the original BN algorithm.
+
+We give a convergence analysis of the algorithm with a two-layer batch-normalized neural network and diminishing stepsizes. We assume two layers (the generalization to multiple layers can be made by using the same approach but substantially complicating the notation) and an arbitrary loss function. The convergence analysis applies to any activation function that follows our common assumption. The main result shows that under diminishing stepsizes on gradient updates and updates on mini-batch statistics, and standard Lipschitz conditions on loss functions DBN converges to a stationary point. As already pointed out the primary challenge is the fact that some trainable parameters are updated by gradient while others are updated by a minor recalculation.
+
+Contributions. The main contribution of this paper is in providing a general convergence guarantee for DBN. Specifically, we make the following contributions.
+
+• In section 4, we show the sufficient and necessary conditions for the stepsizes and diminishing weights to ensure the convergence of BN parameters.   
+• We show that the algorithm converges to a stationary point under a general nonconvex objective function.
+
+This paper is organized as follows. In Section 2, we review the related works and the development of the BN algorithm. We formally state our model and algorithm in Section 3. We present our main results in Sections 4. In Section 5, we numerically show that the DBN algorithm outperforms the original BN algorithm. Proofs for main steps are collected in the Appendix.
+
+# 2 LITERATURE REVIEW
+
+Before the introduction of BN, it has long been known in the deep learning community that input whitening and decorrelation help to speed up the training process. In fact, Orr & Muller show that ¨ preprocessing the data by subtracting the mean, normalizing the variance, and decorrelating the input has various beneficial effects for back-propagation. Krizhevsky et al. propose a method called local response normalization which is inspired by computational neuroscience and acts as a form of lateral inhibition, i.e., the capacity of an excited neuron to reduce the activity of its neighbors. Gulc¸ehre ¨ & Bengio propose a standardization layer that bears significant resemblance to batch normalization, except that the two methods are motivated by very different goals and perform different tasks.
+
+Inspired by BN, several new works are taking BN as a basis for further improvements. Layer normalization Ba et al. (2016) is much like the BN except that it uses all of the summed inputs to compute the mean and variance instead of the mini-batch statistics. Besides, unlike BN, layer normalization performs precisely the same computation at training and test times. Normalization propagation that Arpit et al. uses data-independent estimations for the mean and standard deviation in every layer to reduce the internal covariate shift and make the estimation more accurate for the validation phase. Weight normalization also removes the dependencies between the examples in a minibatch so that it can be applied to recurrent models, reinforcement learning or generative models Salimans & Kingma (2016). Cooijmans et al. propose a new way to apply batch normalization to RNN and LSTM models.
+
+Given all these flavors, the original BN method is the most popular technique and for this reason our choice of the analysis. To the best of our knowledge, we are not aware of any prior analysis of BN.
+
+BN has the gradient and non-gradient updates. Thus, nonconvex convergence results do not immediately transfer. Our analysis explicitly considers the workings of BN. However, nonconvex convergence proofs are relevant since some small portions of our analysis rely on known proofs and approaches.
+
+Neural nets are not convex, even if the loss function is convex. For classical convergence results with a nonconvex objective function and diminishing learning rate, we refer to survey papers Bertsekas (2011); Bertsekas & Tsitsiklis (2000); Bottou et al. (2016). Bertsekas & Tsitsiklis provide a convergence result with the deterministic gradient with errors. Bottou et al. provide a convergence result with the stochastic gradient. The classic analyses showing the norm of gradients of the objective function going to zero date back to Grippo (1994); Polyak & Tsypkin (1973); Polyak (1987). For strongly convex objective functions with a diminishing learning rate, we learn the classic convergence results from Bottou et al..
+
+# 3 MODEL AND ALGORITHM
+
+The optimization problem for a network is an objective function consisting of a large number of component functions, that reads:
+
+$$
+\operatorname* { m i n } { \bar { f } } ( \theta , \lambda ) = \sum _ { i = 1 } ^ { N } f _ { i } ( X _ { i } : \theta , \lambda ) ,
+$$
+
+where $f _ { i } : \mathbb { R } ^ { n _ { 1 } } \times \mathbb { R } ^ { n _ { 2 } } \to \mathbb { R } , i = 1 , . . . , N$ , are real-valued functions for any data record $X _ { i }$ . Index $i$ associates with data record $X _ { i }$ and target response $y _ { i }$ (hidden behind the dependency of $f$ on $i$ ) in the training set. Parameters $\theta$ include the common parameters updated by gradients directly associated with the loss function, i.e., behind the part that we have a parametric model, while BN parameters $\lambda$ are introduced by the BN algorithm and not updated by gradient methods but by the mini-batch statistics. We define that the derivative of $f _ { i }$ is always taken with respect to $\theta$ :
+
+$$
+\nabla f _ { i } ( X _ { i } : \theta , \lambda ) : = \nabla _ { \theta } f _ { i } ( X _ { i } : \theta , \lambda ) .
+$$
+
+The deep network we analyze has 2 fully-connected layers with $D _ { 1 }$ neurons each. The techniques presented can be extended to more layers with additional notation. Each hidden layer computes $y = a ( W u )$ with activation function $a ( \cdot )$ and $u$ is the input vector of the layer. We do not need to include an intercept term since the BN algorithm automatically adjusts for it. BN is applied to the output of the first hidden layer.
+
+![](images/6e81609839f29575b1ba848ea8d9a6fef96936f5163e6621377248f838ad4ff4.jpg)  
+Figure 1: The structure of our batch-normalized network model in the analysis.
+
+We next describe the computation in each layer to show how we obtain the output of the network. The notations introduced here is used in the analysis. Figure 1 shows the full structure of the network. The input data is vector $X$ , which is one of $\{ X _ { i } \} _ { i = 1 } ^ { N }$ . Vector $\lambda = \left( ( \mu _ { j } ) _ { j = 1 } ^ { D } , ( \sigma _ { j } ) _ { j = 1 } ^ { D } \right)$ is the set of all BN parameters and vector $\theta = \left( W _ { 1 } , W _ { 2 } , ( \beta _ { j } ^ { ( 1 ) } ) _ { j = 1 } ^ { D } , ( \gamma _ { j } ^ { ( 1 ) } ) _ { j = 1 } ^ { D } \right)$ is the set of all trainable parameters which are updated by gradients.
+
+Matrices $W _ { 1 } , W _ { 2 }$ are the actual model parameters and $\beta , \gamma$ are introduced by BN. The value of $j ^ { t h }$ neuron of the first hidden layer is
+
+$$
+z _ { j } ^ { ( 1 ) } ( X : \theta ) = a ( W _ { 1 , j , \cdot } X ) ,
+$$
+
+where $W _ { 1 , j , }$ ,· denotes the weights of the linear transformations for the $j ^ { t h }$ neuron.
+
+The $j ^ { t h }$ entry of batch-normalized output of the first layer is
+
+$$
+y _ { j } ^ { ( 1 ) } ( X : \theta , \lambda ) = \gamma _ { j } ^ { ( 1 ) } \left( \frac { z _ { j } ^ { ( 1 ) } ( X : \theta ) - \mu _ { j } } { \sigma _ { j } + \epsilon _ { B } } \right) + \beta _ { j } ^ { ( 1 ) } ,
+$$
+
+where $\beta _ { j } ^ { ( 1 ) }$ and $\gamma _ { j } ^ { ( 1 ) }$ are trainable parameters updated by gradient and $\mu _ { j }$ and $\sigma _ { j }$ are batch normalization parameters for $z _ { j } ^ { ( 1 ) }$ . Trainable parameter $\mu _ { j }$ is the mini-batch mean of $z _ { j } ^ { ( 1 ) }$ and trainable parameter σj is the mini-batch sample deviation of z(1)j . Constant $\epsilon _ { B }$ keeps the denominator from zero. The output of $j ^ { t h }$ entry of the output layer is:
+
+$$
+z _ { j } ^ { ( 2 ) } ( X : \theta ) = a \left( W _ { 2 , j , \cdot } \left[ \gamma _ { j } ^ { ( 1 ) } \left( \frac { z _ { j } ^ { ( 1 ) } ( X : \theta ) - \mu _ { j } } { \sigma _ { j } + \epsilon _ { B } } \right) + \beta _ { j } ^ { ( 1 ) } \right] \right)
+$$
+
+The objective function for the $i ^ { t h }$ sample is
+
+$$
+f _ { i } ( X _ { i } : \theta , \lambda ) = l _ { i } \left( \left( z _ { j } ^ { ( 2 ) } ( X _ { i } : \theta , \lambda ) \right) _ { j } \right) ,
+$$
+
+where $l _ { i } ( \cdot )$ is the loss function associated with the target response $y _ { i }$ . For sample $i$ , we have the following complete expression for the objective function:
+
+$$
+f _ { i } ( X _ { i } : \theta , \lambda ) = l _ { i } \left( a ( \sum _ { j = 1 } ^ { D } W _ { 2 , k , j } \left[ \gamma _ { j } ^ { ( 1 ) } \frac { a ( W _ { 1 , j , } . X _ { i } - \mu _ { j } ) } { \sigma _ { j } + \epsilon _ { B } } + \beta _ { j } ^ { ( 1 ) } \right] ) _ { k } \right) .
+$$
+
+Function $f _ { i } ( X _ { i } : \theta , \lambda )$ is nonconvex with respect to $\theta$ and $\lambda$ .
+
+# 3.1 ALGORITHM
+
+Algorithm 1 shows the algorithm studied herein. There are two deviations from the standard BN algorithm, one of them actually being a generalization. We use the full gradient instead of the more popular stochastic gradient (SG) method. It essentially means that each batch contains the entire training set instead of a randomly chosen subset of the training set. An analysis of SG is potential future research. Although the primary motivation for full gradient update is to reduce the burdensome in showing the convergence, the full gradient method is similar to SG in the sense that both of them go through the entire training set, while full gradient goes through it deterministically and the SG goes through it in expectation. Therefore, it is reasonable to speculate that the SG method has similar convergence property as the full algorithm studied herein.
+
+# Algorithm 1 DBN: Diminishing Batch-Normalized Network Update Algorithm
+
+<table><tr><td>1: Initializeθ ∈ Rn1 and X ∈Rn2 for iteration m=1,2.,.. do</td><td></td></tr><tr><td>2:</td><td>((m+1):=0(m）-n(m)∑1fi(Xi:0(m）,(m))</td></tr><tr><td>3:</td><td></td></tr><tr><td>4:</td><td>for j=1..,.D do</td></tr><tr><td>5:</td><td>μm+1）:=∑N12（xt:0(m+1））</td></tr><tr><td>6:</td><td>)=∑（(）</td></tr><tr><td>7:</td><td>(1):(）（）））+）</td></tr></table>
+
+The second difference is that we update the BN parameters $( \theta , \lambda )$ by their moving averages with respect to diminishing $\alpha ^ { ( m ) }$ . The original BN algorithm can be recovered by setting $\alpha ^ { ( m ) } = 1$ for every $m$ . After introducing diminishing $\alpha ^ { ( m ) }$ , $\lambda ^ { ( m ) }$ and hence the output of the BN layer is determined by the history of all past data records, instead of those solely in the last batch. Thus, the output of the BN layer becomes more general that better reflects the distribution of the entire dataset. We use two strategies to decide the values of $\alpha ^ { ( m ) }$ . One is to use a constant smaller than 1 for all $m$ , and the other one is to decay the $\alpha ^ { ( m ) }$ gradually, such as $\alpha ^ { ( m ) } = 1 / m$ .
+
+In our numerical experiment, we show that Algorithm 1 outperforms the original BN algorithm, where both are based on SG and non-linear activation functions with many layers FNN and CNN models.
+
+# 4 GENERAL CASE
+
+The main purpose of our work is to show that Algorithm 1 converges. In the general case, we focus on the nonconvex objective function.
+
+# 4.1 ASSUMPTIONS
+
+Here are the assumptions we used for the convergence analysis.
+
+Assumption 1 (Lipschitz continuity on $\theta$ and $\lambda$ ). For every $i$ we have
+
+$$
+\begin{array} { r l r } & { } & { \Vert \nabla f _ { i } ( X : \tilde { \theta } , \lambda ) - \nabla f _ { i } ( X : \hat { \theta } , \lambda ) \Vert _ { 2 } \leq \bar { L } \Vert \tilde { \theta } - \hat { \theta } \Vert _ { 2 } , \forall \tilde { \theta } , \hat { \theta } , \lambda , } \\ & { } & \\ & { } & { \Vert \nabla _ { W _ { 1 , j , \cdot } } f _ { i } ( X : \tilde { \theta } , \lambda ) - \nabla _ { W _ { 1 , j , \cdot } } f _ { i } ( X : \hat { \theta } , \lambda ) \Vert _ { 2 } } \\ & { } & { \leq \bar { L } \Vert \tilde { W } _ { 1 , j , \cdot } - \hat { W } _ { 1 , j , \cdot } \Vert _ { 2 } , \forall \lambda , \tilde { \theta } , \hat { \theta } , X , j \in \{ 1 , . . . , D _ { 1 } \} . } \\ & { } & { \Vert \nabla f _ { i } ( X : \theta , \tilde { \lambda } ) - \nabla f _ { i } ( X : \theta , \hat { \lambda } ) \Vert _ { 2 } \leq \bar { L } \Vert \tilde { \lambda } - \hat { \lambda } \Vert _ { 2 } , } \\ & { } & { \forall \theta , \tilde { \lambda } , \hat { \lambda } , X , j \in \{ 1 , . . . , D _ { 1 } \} . } \end{array}
+$$
+
+Noted that the Lipschitz constants associated with each of the above inequalities are not necessarily the same. Here $\bar { L }$ is an upper bound for these Lipschitz constants for simplicity.
+
+Assumption 2 (bounded parameters). Sets $P$ and $Q$ are compact set, where $\theta \in P$ and $\lambda \in Q$ . Thus, there exists a constant $M$ that weights $W$ and parameters $\lambda$ are bounded element-wise by this constant $M$ .
+
+$$
+\lVert W _ { 1 } \rVert \preceq M a n d \lVert W _ { 2 } \rVert \preceq M a n d \lVert \lambda \rVert \preceq M .
+$$
+
+This also implies that the updated $\theta , \lambda$ in Algorithm 1 remain in $P$ and $Q$ , respectively.
+
+Assumption 3 (diminishing update on $\theta$ ). The stepsizes of $\theta$ update satisfy
+
+$$
+\sum _ { m = 1 } ^ { \infty } \eta ^ { ( m ) } = \infty a n d \sum _ { m = 1 } ^ { \infty } ( \eta ^ { ( m ) } ) ^ { 2 } < \infty .
+$$
+
+This is a common assumption for diminishing stepsizes in optimization problems.
+
+Assumption 4 (Lipschitz continuity of $l _ { i } ( \cdot ) .$ ). Assume the loss functions $l _ { i } ( \cdot )$ for every $i$ is continuously differentiable. It implies that there exists $\hat { M }$ such that
+
+$$
+\lVert l _ { i } ( x ) - l _ { i } ( y ) \rVert \leq \hat { M } \lVert x - y \rVert , \forall x , y .
+$$
+
+Assumption 5 (existence of a stationary point). There exists a stationary point $( \theta ^ { * } , \lambda ^ { * } )$ such that $\| \nabla \bar { f } ( \theta ^ { \ast } , \lambda ^ { \ast } ) \| = 0$ .
+
+We note that all these are standard assumptions in convergence proofs. We also stress that Assumption 4 does not directly imply 1. Since we assume that $P$ and $Q$ are compact, then Assumptions 1, 4 and 5 hold for many standard loss function such as softmax and MSE.
+
+Assumption 6 (Lipschitz at activation function). The activation function $a ( \cdot )$ is Lipschitz with constant $k$ :
+
+$$
+| a ( x ) | \leq k \| x \|
+$$
+
+Since for all activation function there is $a ( 0 ) = 0$ , the condition is equivalent to $| a ( x ) - a ( 0 ) | \leq$ $k \| x - 0 \|$ . We note that this assumption works for many popular choices of activation functions, such as ReLU and LeakyReLu.
+
+# 4.2 CONVERGENCE ANALYSIS
+
+We first have the following lemma specifying sufficient conditions for $\lambda$ to converge. Proofs for main steps are given in the Appendix.
+
+Theorem 7 Under Assumptions 1, 2, 3 and 6, if $\{ \alpha ^ { ( m ) } \}$ satisfies
+
+$$
+\sum _ { m = 1 } ^ { \infty } \alpha ^ { ( m ) } < \infty a n d \sum _ { m = 1 } ^ { \infty } \sum _ { n = 1 } ^ { m } \alpha ^ { ( m ) } \eta ^ { ( n ) } < \infty ,
+$$
+
+then sequence $\{ \lambda ^ { ( m ) } \}$ converges to $\bar { \lambda } .$
+
+We give a discussion of the above conditions for $\alpha ^ { ( m ) }$ and $\eta ^ { ( m ) }$ at the end of this section. With the help of Theorem 7, we can show the following convergence result.
+
+Lemma 8 Under Assumptions 4, 5 and the assumptions of Theorem 7, when
+
+$$
+\sum _ { m = 1 } ^ { \infty } \sum _ { i = m } ^ { \infty } \sum _ { n = 1 } ^ { i } \alpha ^ { ( i ) } \eta ^ { ( n ) } < \infty \quad a n d \quad \sum _ { m = 1 } ^ { \infty } \sum _ { n = m } ^ { \infty } \alpha ^ { ( n ) } < \infty ,
+$$
+
+we have
+
+$$
+\operatorname* { l i m } _ { M \to \infty } \sum _ { m = 1 } ^ { M } \eta ^ { ( m ) } \| \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \| _ { 2 } ^ { 2 } < \infty .
+$$
+
+This result is similar to the classical convergence rate analysis for the non-convex objective function with diminishing stepsizes, which can be found in Bottou et al. (2016).
+
+Lemma 9 Under the assumptions of Lemma 8, we have
+
+$$
+\operatorname* { l i m } _ { m \to \infty } \lvert \operatorname* { n f } _ { \mathbf { \theta } } \rvert | \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \rvert | _ { 2 } ^ { 2 } = 0 .
+$$
+
+This theorem states that for the full gradient method with diminishing stepsizes the gradient norms cannot stay bounded away from zero. The following result characterizes more precisely the convergence property of Algorithm 1.
+
+Lemma 10 Under the assumptions stated in Lemma 8, we have
+
+$$
+\operatorname* { l i m } _ { m \to \infty } \| \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \| _ { 2 } ^ { 2 } = 0 .
+$$
+
+Our main result is listed next.
+
+Theorem 11 Under the assumptions stated in Lemma 8, we have
+
+$$
+\operatorname* { l i m } _ { m \to \infty } \lVert \nabla \bar { f } ( \theta ^ { ( m ) } , \lambda ^ { ( m ) } ) \rVert _ { 2 } ^ { 2 } = 0 .
+$$
+
+We cannot show that $\{ \theta ^ { ( m ) } \}$ ’s converges (standard convergence proofs are also unable to show such a stronger statement). For this reason, Theorem 11 does not immediately follow from Lemma 10 together with Theorem 7. The statement of Theorem 11 would easily follow from Lemma 10 if the convergence of $\{ \theta ^ { ( m ) } \}$ is established and the gradient being continuous.
+
+Considering the cases $\begin{array} { r } { \eta ^ { ( m ) } = { O } \left( \frac { 1 } { m ^ { k } } \right) } \end{array}$ and $\begin{array} { r } { \alpha ^ { ( m ) } = { O } \left( \frac { 1 } { m ^ { h } } \right) } \end{array}$ . We show in the Appendix that the set of sufficient and necessary conditions to satisfy the assumptions of Theorem 7 are $h > 1$ and $k \geq 1$ . The set of sufficient and necessary conditions to satisfy the assumptions of Lemma 8 are $h > 2$ and $k \geq 1$ . For example, we can pick $\begin{array} { r } { \eta ^ { ( m ) } = { O } \left( \frac { 1 } { m } \right) } \end{array}$ and $\begin{array} { r } { \alpha ^ { ( m ) } = { \bar { O } } { \left( \frac { 1 } { m ^ { 2 . 0 0 1 } } \right) } } \end{array}$ to achieve the above convergence result in Theorem 11.
+
+# 5 COMPUTATIONAL EXPERIMENTS
+
+We conduct the computational experiments with Theano and Lasagne on a Linux server with a Nvidia Titan-X GPU. We use MNIST LeCun et al. (1998), CIFAR-10 Krizhevsky & Hinton (2009) and Network Intrusion (NI) kdd (1999) datasets to compare the performance between DBN and the original BN algorithm. For the MNIST dataset, we use a four-layer fully connected FNN ( $7 8 4 \times$ $3 0 0 \times 3 0 0 \times 1 0 \%$ with the ReLU activation function and for the NI dataset, we use a four-layer fully connected FNN $7 8 4 \times 5 0 \times 5 0 \times 1 0 )$ with the ReLU activation function. For the CIFAR-10 dataset, we use a reasonably complex CNN network that has a structure of (Conv-Conv-MaxPool-DropoutConv-Conv-MaxPool-Dropout-FC-Dropout-FC), where all four convolution layers and the first fully connected layers are batch normalized. We use the softmax loss function and $l _ { 2 }$ regularization with for all three models. All the trainable parameters are randomly initialized before training. For all 3 datasets, we use the standard epoch/minibatch setting with the minibatch size of 100, i.e., we do not compute the full gradient and the statistics are over the minibatch. We use AdaGrad Duchi, John and Hazan, Elad and Singer (2011) to update the learning rates $\eta ^ { ( m ) }$ for trainable parameters, starting from 0.01.
+
+We use two different strategies to decide the values of $\alpha ^ { ( m ) }$ in DBN: constant values of $\alpha ^ { ( m ) }$ and diminishing $\alpha ^ { ( m ) }$ where $\alpha ^ { ( \bar { m } ) } = 1 / m$ and $\alpha ^ { ( m ) } = 1 / m ^ { 2 }$ . We test the choices of constant $\alpha ^ { ( m ) } \in$ $\{ 1 , 0 . 7 5 , 0 . 5 , 0 . 2 5 , 0 . 1 , 0 . 0 1 , 0 . 0 0 1 , 0 \}$ .
+
+![](images/3653c8b21c801d9109db762eb6b555481f06eb3409d8901201289f45a7a7b4a3.jpg)  
+Figure 2: Comparison of predicted accuracy on test datasets for different choices of $\alpha ^ { ( m ) }$ . From left to right are FNN on MNIST, FNN on NI and CNN on CIFAR-10.
+
+![](images/f3900582c3bb1567acdb716ab19d6b86cb04e19deb6ec5f757d4a7abb6ed29b2.jpg)  
+Figure 3: Comparison of predicted accuracy on test datasets for the most efficient choices of $\alpha ^ { ( m ) }$ . From left to right are FNN on MNIST, FNN on NI and CNN on CIFAR-10.
+
+![](images/da9b724a344b0488a7b3a9d92e6858ed428c1a210ef42c46bca9d59ad039be28.jpg)  
+Figure 4: Comparison of the convergence of the loss function value on the validation set for different choices of $\bar { \alpha } ^ { ( m ) }$ . From left to right are FNN on MNIST, FNN on NI and CNN on CIFAR-10.
+
+We test all the choices of $\alpha ^ { ( m ) }$ with the performances presented in Figure 2. Figure 2 shows that all the non-zero choices of $\alpha ^ { ( m ) }$ converge properly. The algorithms converge without much difference even when $\alpha ^ { ( m ) }$ in DBN is very small, e.g., $1 / m ^ { 2 }$ . However, if we select $\alpha ^ { ( m ) } = 0$ , the algorithm is erratic. Besides, we observe that all the non-zero choices of $\alpha ^ { ( m ) }$ converge at a similar rate. The fact that DBN keeps the batch normalization layer stable with a very small $\alpha ^ { ( m ) }$ suggests that the BN parameters do not have to be depended on the latest minibatch, i.e., the original BN.
+
+We compare a selected set of the most efficient choices of $\alpha ^ { ( m ) }$ in Figures 3 and 4. They show that DBN with $\alpha ^ { ( m ) } < 1$ is more stable than the original BN algorithm. The variances with respect to epochs of the DBN algorithm are smaller than those of the original BN algorithms in each figure.
+
+Table 1: Best results for different choices of $\alpha ^ { ( m ) }$ on each dataset, showing the top three with a heat map.   
+
+<table><tr><td></td><td colspan="3">Test Error</td></tr><tr><td>Model</td><td>MNIST</td><td>NI</td><td>CIFAR-10</td></tr><tr><td>a(m） =1</td><td>2.70%</td><td>7.69%</td><td>17.31%</td></tr><tr><td>Q（m） =0.75</td><td>1.91%</td><td>7.37%</td><td>17.03%</td></tr><tr><td>a（m） = 0.5</td><td>1.84%</td><td>7.46%</td><td>17.11%</td></tr><tr><td>a(m） =0.25</td><td>1.91%</td><td>7.24%</td><td>17.00%</td></tr><tr><td>a(m) =0.1</td><td>1.90%</td><td>7.36%</td><td>17.10%</td></tr><tr><td>a（m） =0.01</td><td>1.94%</td><td>7.47%</td><td>16.82%</td></tr><tr><td>q(m) =0.001</td><td>1.95%</td><td>7.43%</td><td>16.28%</td></tr><tr><td>Q(m) =1/m</td><td>2.10%</td><td>7.45%</td><td>17.26%</td></tr><tr><td>a(m） =1/m²</td><td>2.00%</td><td>7.59%</td><td>17.23%</td></tr><tr><td>a(m）=0</td><td>24.27%</td><td>26.09%</td><td>79.34%</td></tr></table>
+
+Table 1 shows the best result obtained from each choice of $\alpha ^ { ( m ) }$ . Most importantly, it suggests that the choices of $\alpha ^ { ( m ) } = 1 / m$ and $1 / m ^ { 2 }$ perform better than the original BN algorithm. Besides, all the constant less-than-one choices of $\alpha ^ { ( m ) }$ perform better than the original BN, showing the importance of considering the mini-batch history for the update of the BN parameters. The BN algorithm in each figure converges to similar error rates on test datasets with different choices of $\alpha ^ { ( m ) }$ except for the $\alpha ^ { ( m ) } = 0$ case. Among all the models we tested, $\alpha ^ { ( m ) } = 0 . 2 5$ is the only one that performs top 3 for all three datasets, thus the most robust choice.
+
+To summarize, our numerical experiments show that the DBN algorithm outperforms the original BN algorithm on the MNIST, NI and CIFAT-10 datasets with typical deep FNN and CNN models.
+
+Future Directions. On the analytical side, we believe an extension to more than 2 layers is doable with significant augmentations of the notation. A stochastic gradient version is likely to be much more challenging to analyze. A second open question concerns more general activation functions. It would be interesting to analyze other activation functions, such as Sigmoid, that do not apply to our current assumptions.
+
+REFERENCES   
+KDD Cup 1999 Data, 1999. URL http://www.kdd.org/kdd-cup/view/ kdd-cup-1999/Data.   
+Devansh Arpit, Yingbo Zhou, Bhargava U. Kota, and Venu Govindaraju. Normalization Propagation: A Parametric Technique for Removing Internal Covariate Shift in Deep Networks. In International Conference on Machine Learning, volume 48, pp. 11, 2016.   
+Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E. Hinton. Layer Normalization. arXiv preprint arXiv:1607.06450, 2016.   
+Dimitri P. Bertsekas. Incremental gradient, subgradient, and proximal methods for convex optimization: A Survey. Optimization for Machine Learning, 2010(3):1–38, 2011.   
+Dimitri P. Bertsekas and John N. Tsitsiklis. Gradient Convergence in Gradient Methods with Errors. SIAM Journal on Optimization, 10:627–642, 2000.   
+Leon Bottou, Frank E. Curtis, and Jorge Nocedal. Optimization Methods for Large-Scale Machine ´ Learning. arXiv preprint arXiv:1606.04838, 2016.   
+Tim Cooijmans, Nicolas Ballas, Cesar Laurent, and Aaron Courville. Recurrent Batch Normaliza- ´ tion. arXiv preprint arXiv:1603.09025, 2016.   
+Yoram Duchi, John and Hazan, Elad and Singer. Adaptive Subgradient Methods for Online Learning and Stochastic Optimization. Journal of Machine Learning Research, 12(Jul):2121–2159, 2011.   
+L. Grippo. A Class of Unconstrained Minimization Methods for Neural Network Training. Optimization Methods and Software, 4(2):135–150, 1994.   
+C¸ aglar Gulc¸ehre and Yoshua Bengio. Knowledge Matters: Importance of Prior Information for ¨ Optimization. Journal of Machine Learning Research, 17(8):1–32, 2016.   
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep Residual Learning for Image Recognition. In Computer Vision and Pattern Recognition, pp. 770–778, dec 2016.   
+Sergey Ioffe and Christian Szegedy. Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift. In International Conference on Machine Learning, pp. 448–456, 2015.   
+Alex Krizhevsky and Geoffrey E. Hinton. Learning Multiple Layers of Features from Tiny Images. PhD thesis, 2009.   
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet Classification with Deep Convolutional Neural Networks. In Advances in neural information processing systems, pp. 1097–1105, 2012.   
+Yann LeCun, Leon Bottou, and Yoshua Bengio. Gradient-based learning applied to document recog- ´ nition. Proceedings of the IEEE, 86(11):2278–2324, 1998.   
+Genevieve B. Orr and Klaus-Robert Muller. ¨ Neural Networks: Tricks of the Trade. Springer, New York, 2003.   
+B. T. Polyak. Introduction to optimization. Translations series in mathematics and engineering. Optimization Software, 1987.   
+B. T. Polyak and Y. Z. Tsypkin. Pseudogradient Adaption and Training Algorithms. Automation and Remote Control, 34:45–67, 1973.   
+Tim Salimans and Diederik P. Kingma. Weight Normalization: A Simple Reparameterization to Accelerate Training of Deep Neural Networks. In Advances in Neural Information Processing Systems, pp. 901–901, 2016.
+
+# 6 APPENDIX: PROOFS
+
+# 6.1 PRELIMINARY RESULTS
+
+The following proofs are shortened to corporate with AAAI submission page limit.
+
+Proposition 12 There exists a constant M such that, for any $\theta$ and fixed $\lambda$ , we have
+
+$$
+\begin{array} { r } { \| \nabla \bar { f } ( \theta , \lambda ) \| _ { 2 } ^ { 2 } \leq M . } \end{array}
+$$
+
+Proof. By Assumption 5, we know there exists $( \theta ^ { * } , \lambda ^ { * } )$ such that $\| \nabla \bar { f } ( \theta ^ { * } , \lambda ^ { * } ) \| _ { 2 } = 0$ . Then we have
+
+$$
+\begin{array} { l } { \displaystyle | | \nabla \bar { f } ( \theta , \lambda ) | | _ { 2 } } \\ { = | | \nabla \bar { f } ( \theta , \lambda ) | | _ { 2 } - | | \nabla \bar { f } ( \theta , \lambda ^ { * } ) | | _ { 2 } + | | \nabla \bar { f } ( \theta , \lambda ^ { * } ) | | _ { 2 } - | | \nabla \bar { f } ( \theta ^ { * } , \lambda ^ { * } ) | | _ { 2 } } \\ { \displaystyle \le | | \nabla \bar { f } ( \theta , \lambda ) - \nabla \bar { f } ( \theta , \lambda ^ { * } ) | | _ { 2 } + | | \nabla \bar { f } ( \theta , \lambda ^ { * } ) - \nabla \bar { f } ( \theta ^ { * } , \lambda ^ { * } ) | | _ { 2 } } \\ { \displaystyle \le \sum _ { i = 1 } ^ { N } | | \nabla f _ { i } ( X _ { i } : \theta , \lambda ) - \nabla f _ { i } ( X _ { i } : \theta , \lambda ^ { * } ) | | _ { 2 } } \\ { + \displaystyle \sum _ { i = 1 } ^ { N } | | \nabla f _ { i } ( X _ { i } : \theta , \lambda ^ { * } ) - \nabla f _ { i } ( X _ { i } : \theta ^ { * } , \lambda ^ { * } ) | | _ { 2 } } \\ { \displaystyle \le N \bar { L } ( | \lambda - \lambda ^ { * } | | _ { 2 } + | | \theta - \theta ^ { * } | | _ { 2 } ) , } \end{array}
+$$
+
+where the last inequality is by Assumption 1. We then have
+
+$$
+\begin{array} { r } { \| \nabla \bar { f } ( \theta , \lambda ) \| _ { 2 } ^ { 2 } \leq N ^ { 2 } \bar { L } ^ { 2 } ( \| \lambda - \lambda ^ { * } \| _ { 2 } + \| \theta - \theta ^ { * } \| _ { 2 } ) ^ { 2 } \leq M , } \end{array}
+$$
+
+because sets $\mathrm { P }$ and $\mathrm { Q }$ are compact by Assumption 2.
+
+Proposition 13 We have
+
+$$
+f _ { i } ( \boldsymbol { X } : \tilde { \boldsymbol { \theta } } , \lambda ) \leq f _ { i } ( \boldsymbol { X } : \hat { \boldsymbol { \theta } } , \lambda ) + \nabla f _ { i } ( \boldsymbol { X } : \hat { \boldsymbol { \theta } } , \lambda ) ^ { T } ( \tilde { \boldsymbol { \theta } } - \hat { \boldsymbol { \theta } } ) + \frac { 1 } { 2 } \bar { L } \| \tilde { \boldsymbol { \theta } } - \hat { \boldsymbol { \theta } } \| _ { 2 } ^ { 2 } , \forall \tilde { \boldsymbol { \theta } } , \hat { \boldsymbol { \theta } } , \boldsymbol { X } .
+$$
+
+Proof. This is a known result of the Lipschitz-continuous condition that can be found in Bottou et al. (2016).   
+We have this result together with Assumption 1.
+
+# 6.2 PROOF OF THEOREM 7
+
+$$
+\begin{array} { r l } & { \mathbf { L e m m a 1 4 } \ : \ : W h e n \sum _ { m = 1 } ^ { \infty } \alpha ^ { ( m ) } < \infty a n d \ : \sum _ { m = 1 } ^ { \infty } \sum _ { n = 1 } ^ { m } \alpha ^ { ( m ) } \eta ^ { ( n ) } < \infty , } \\ & { \tilde { \mu } _ { j } ^ { ( m ) } : = \frac { \mu _ { j } ^ { ( m ) } } { \left( 1 - \alpha ^ { ( 1 ) } \right) \left( 1 - \alpha ^ { ( 2 ) } \right) \ldots \left( 1 - \alpha ^ { ( m ) } \right) } i s a c a u c h y s e r i e s . } \end{array}
+$$
+
+Proof. By Algorithm 1, we have
+
+$$
+\mu _ { j } ^ { ( m ) } = \alpha ^ { ( m ) } \frac { 1 } { N } \sum _ { i = 1 } ^ { N } a ( W _ { 1 , j , \cdot } ^ { ( m ) } X _ { i } ) + ( 1 - \alpha ^ { ( m ) } ) \mu _ { j } ^ { ( m - 1 ) } .
+$$
+
+We define $\tilde { \alpha } ^ { ( m ) } : = \frac { \alpha ^ { ( m ) } } { ( 1 - \alpha ^ { ( 1 ) } ) ( 1 - \alpha ^ { ( 2 ) } ) . . . ( 1 - \alpha ^ { ( m ) } ) }$ and ∆W (m)1,j,· : $\Delta W _ { 1 , j , \cdot } ^ { ( m ) } : = W _ { 1 , j , \cdot } ^ { ( m ) } - W _ { 1 , j , \cdot } ^ { ( m - 1 ) }$ . After dividing equation 21 by $( 1 - \alpha ^ { ( 1 ) } ) ( 1 - \alpha ^ { ( 2 ) } ) . . . ( 1 - \alpha ^ { ( m ) } )$ , we obtain
+
+$$
+\tilde { \mu } _ { j } ^ { ( m ) } = \tilde { \alpha } ^ { ( m ) } \frac { 1 } { N } \sum _ { i = 1 } ^ { N } a ( W _ { 1 , j , \cdot } ^ { ( m ) } X _ { i } ) + \tilde { \mu } _ { j } ^ { ( m - 1 ) } .
+$$
+
+Then we have
+
+$$
+| \tilde { \mu } _ { j } ^ { ( m ) } - \tilde { \mu } _ { j } ^ { ( m - 1 ) } | \leq \tilde { \alpha } ^ { ( m ) } | k | \frac { 1 } { N } \sum _ { i = 1 } ^ { N } | \sum _ { n = 1 } ^ { m } \Delta W _ { 1 , j , \cdot } ^ { ( n ) } X _ { i } |
+$$
+
+$$
+= \tilde { \alpha } ^ { ( m ) } | k | \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \left| \sum _ { n = 1 } ^ { m } \left( \eta ^ { ( n ) } \sum _ { l = 1 } ^ { N } \nabla _ { W _ { 1 , j , . } } f _ { l } ( X _ { l } : \theta ^ { ( n ) } , \lambda ^ { ( n ) } ) \right) \cdot X _ { i } \right|
+$$
+
+$$
+= \tilde { \alpha } ^ { ( m ) } | k | \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \sum _ { n = 1 } ^ { m } \left( \eta ^ { ( n ) } \left| \left( \sum _ { l = 1 } ^ { N } \nabla _ { W _ { 1 , j , . } } f _ { l } ( X _ { l } : \theta ^ { ( n ) } , \lambda ^ { ( n ) } ) \right) \cdot X _ { i } \right| \right)
+$$
+
+$$
+\leq \tilde { \alpha } ^ { ( m ) } | k | \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \sum _ { n = 1 } ^ { m } \left( \eta ^ { ( n ) } \| \sum _ { l = 1 } ^ { N } \nabla _ { W _ { 1 , j , . } } f _ { l } ( X _ { l } : \theta ^ { ( n ) } , \lambda ^ { ( n ) } ) \| \cdot \| X _ { i } \| \right)
+$$
+
+$$
+\begin{array} { r l } & { \displaystyle \le \tilde { \alpha } ^ { ( m ) } | k | \sum _ { i = 1 } ^ { N } \sum _ { n = 1 } ^ { m } \eta ^ { ( n ) } \left( \bar { L } \cdot ( \| W _ { 1 , j , \cdot } ^ { ( n ) } - W _ { 1 , j , \cdot } ^ { * } \| _ { 2 } + \| \lambda _ { j , \cdot } ^ { ( n ) } - \lambda _ { j , \cdot } ^ { * } \| _ { 2 } ) \cdot \| X _ { i } \| _ { 2 } \right) } \\ & { \qquad \le \tilde { \alpha } ^ { ( m ) } \displaystyle \sum _ { n = 1 } ^ { m } \left( \eta ^ { ( n ) } \right) | k | \displaystyle \sum _ { i = 1 } ^ { N } \left( 2 \bar { L } M \| X _ { i } \| _ { 2 } \right) } \\ & { \qquad \le \tilde { \alpha } ^ { ( m ) } \displaystyle \sum _ { n = 1 } ^ { m } \eta ^ { ( n ) } \displaystyle \tilde { M } _ { \bar { L } , M } . } \end{array}
+$$
+
+$\begin{array} { r } { W _ { 1 , i , j } ^ { ( m ) } = \sum _ { n = 1 } ^ { m } \Delta W _ { 1 , i , j } ^ { ( n ) } } \end{array}$
+
+Therefore,
+
+$$
+\lvert \tilde { \mu } _ { j } ^ { ( p ) } - \tilde { \mu } _ { j } ^ { ( q ) } \rvert \leq \tilde { M } _ { \bar { L } , M } \cdot \sum _ { m = p } ^ { q } \sum _ { n = 1 } ^ { m } \tilde { \alpha } ^ { ( m ) } \eta ^ { ( n ) } .
+$$
+
+It remains to show that
+
+$$
+\begin{array} { c } { { \displaystyle \displaystyle \sum _ { m = 1 } ^ { \infty } \alpha ^ { ( m ) } < \infty \mathrm { , } } } \\ { { \displaystyle \sum _ { m = 1 } ^ { \infty } \displaystyle \sum _ { n = 1 } ^ { m } \alpha ^ { ( m ) } \eta ^ { ( n ) } < \infty \mathrm { , } } } \end{array}
+$$
+
+implies the convergence of $\{ \tilde { \mu } ^ { ( m ) } \}$ . By (28), we have $\Pi _ { m = 1 } ^ { \infty } \big ( 1 - \alpha ^ { ( m ) } \big ) > 0$ , since $\ln ( \Pi _ { m = 1 } ^ { \infty } ( 1 - \alpha ^ { ( m ) } ) ) >$ $\textstyle \sum _ { m = 1 } ^ { \infty } - \alpha ^ { ( m ) } > - \infty$ .
+
+It is also easy to show that there exists $C$ and $M _ { c }$ such that for all $m \geq M _ { c }$ , we have
+
+Therefore,
+
+$$
+\begin{array} { c } { ( 1 - \alpha ^ { ( 1 ) } ) ( 1 - \alpha ^ { ( 2 ) } ) \dots ( 1 - \alpha ^ { ( m ) } ) \ge C . } \\ { \displaystyle \operatorname* { l i m } _ { \imath \to \infty } ( 1 - \alpha ^ { ( 1 ) } ) ( 1 - \alpha ^ { ( 2 ) } ) \dots ( 1 - \alpha ^ { ( m ) } ) \ge C . } \end{array}
+$$
+
+Thus the following holds:
+
+$$
+\tilde { \alpha } ^ { ( m ) } \leq \frac { 1 } { C } \alpha ^ { ( m ) }
+$$
+
+and
+
+$$
+\sum _ { m = p } ^ { q } \sum _ { n = 1 } ^ { m } \tilde { \alpha } ^ { ( m ) } \eta ^ { ( n ) } \leq \frac { 1 } { C } \sum _ { m = p } ^ { q } \sum _ { n = 1 } ^ { m } \alpha ^ { ( m ) } \eta ^ { ( n ) } .
+$$
+
+From equation 29 and equation 32 it follows that the sequence $\{ \tilde { \mu } _ { j } ^ { ( m ) } \}$ is a Cauchy series.
+
+Lemma 15 Since $\{ \tilde { \mu } _ { j } ^ { ( m ) } \}$ is a Cauchy series, $\{ \mu _ { j } ^ { ( m ) } \}$ is a Cauchy series.
+
+Proof. We know that $\mu _ { j } ^ { ( m ) } = \tilde { \mu } _ { j } ^ { ( m ) } ( 1 { - } \alpha ^ { ( 1 ) } ) . . . ( 1 { - } \alpha ^ { ( m ) } )$ . Since $\operatorname* { l i m } _ { m  \infty } \tilde { \mu } _ { j } ^ { ( m ) }  \tilde { \mu } _ { j }$ and $\operatorname* { l i m } _ { m \to \infty } ( 1 - \alpha ^ { ( 1 ) } ) . . . ( 1 -$ $\alpha ^ { ( m ) } )  \tilde { C }$ , we have $\operatorname* { l i m } _ { m  \infty } \mu _ { j } ^ { ( m ) }  \tilde { \mu } _ { j } \cdot \tilde { C }$ . Thus $\mu _ { j } ^ { ( m ) }$ is a Cauchy series. 
+
+Lemma 16 If $\textstyle \sum _ { m = 1 } ^ { \infty } \alpha ^ { ( m ) } < \infty$ and $\begin{array} { r } { \sum _ { m = 1 } ^ { \infty } \sum _ { n = 1 } ^ { m } \alpha ^ { ( m ) } \eta ^ { ( n ) } < \infty , \left\{ c \right. } \qquad \end{array}$ $\{ \sigma _ { j } ^ { ( m ) } \}$ is a Cauchy series.
+
+Proof. We define $\sigma _ { j } ^ { ( m ) } : = \tilde { \sigma } _ { j } ^ { ( m ) } ( 1 - \alpha ^ { ( 1 ) } ) . . . ( 1 - \alpha ^ { ( m ) } ) \ / \nonumber$ . Then we have
+
+$$
+| \tilde { \sigma } _ { j } ^ { ( m + 1 ) } - \tilde { \sigma } _ { j } ^ { ( m ) } | = \tilde { \alpha } ^ { ( m ) } \sqrt { \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \left( a ( W _ { 1 , j , } ^ { ( m ) } X _ { i } ) - \mu _ { j } ^ { ( m ) } \right) ^ { 2 } }
+$$
+
+$$
+= \tilde { \alpha } ^ { ( m ) } \frac { | k | } { \sqrt { N } } \sqrt { \sum _ { i = 1 } ^ { N } { \left( \frac { a ( W _ { 1 , j , \cdot } ^ { ( m ) } X _ { i } ) } { k } - \frac { \mu _ { j } ^ { ( m ) } } { k } \right) ^ { 2 } } } .
+$$
+
+Since $\{ \mu _ { j } ^ { ( m ) } \}$ is convergent, there exists $c _ { 1 } , c _ { 2 }$ and $N _ { 1 }$ such that for any $m > N _ { 1 } , - \infty < c _ { 1 } < \mu _ { j } ^ { ( m ) } < c _ { 2 } <$ $\infty$ . For any $\bar { C } \in \left\{ \frac { c _ { 1 } } { k } , \frac { c _ { 2 } } { k } \right\}$ , we have
+
+$$
+| \tilde { \sigma } _ { j } ^ { ( m + 1 ) } - \tilde { \sigma } _ { j } ^ { ( m ) } | \leq \tilde { \alpha } ^ { ( m ) } \frac { | k | } { \sqrt { N } } \cdot \sqrt { \sum _ { i = 1 } ^ { N } \left( \frac { a ( W _ { 1 , j , } ^ { ( m ) } X _ { i } ) } { k } - \bar { C } \right) ^ { 2 } }
+$$
+
+$$
+\leq \tilde { \alpha } ^ { ( m ) } \frac { | k | } { \sqrt { N } } \cdot \sqrt { \sum _ { i = 1 } ^ { N } \left( | \frac { a ( W _ { 1 , j , \cdot } ^ { ( m ) } X _ { i } ) } { k } | + | \bar { C } | \right) ^ { 2 } }
+$$
+
+$$
+\leq \tilde { \alpha } ^ { ( m ) } \frac { \vert k \vert } { \sqrt { N } } \cdot \sqrt { \sum _ { i = 1 } ^ { N } \left( \sum _ { n = 1 } ^ { m } \eta ^ { ( n ) } \left( 2 N \bar { L } M \| X _ { i } \| _ { 2 } \right) + | \bar { C } | \right) ^ { 2 } }
+$$
+
+$$
+\leq \tilde { \alpha } ^ { ( m ) } \frac { | k | } { \sqrt { N } } \cdot \sqrt { N \cdot \left( \tilde { M } _ { \bar { L } , M } \sum _ { n = 1 } ^ { m } \eta ^ { ( n ) } + | \bar { C } | \right) ^ { 2 } }
+$$
+
+$$
+= \tilde { \alpha } ^ { ( m ) } | k | \cdot \left( \tilde { M } _ { \bar { L } , M } \sum _ { n = 1 } ^ { m } \eta ^ { ( n ) } + | \bar { C } | \right) .
+$$
+
+Inequality equation 35 is by the following fact:
+
+$$
+\sqrt { \sum _ { i = 1 } ^ { n } ( a _ { i } - c ) ^ { 2 } } \leq \sqrt { \sum _ { i = 1 } ^ { n } ( | a _ { i } | + | c | ) ^ { 2 } } ,
+$$
+
+where $^ { b }$ and $a _ { i }$ for every $_ { i }$ are arbitrary real scalars. Besides, equation 39 is due to $\_ \subseteq$ $\operatorname* { m a x } \{ - 2 | a _ { i } | c , 2 | a _ { i } | c \}$ .
+
+Inequality equation 36 follow from the square function being increasing for nonnegative numbers. Besides these facts, equation 36 is also by the same techniques we used in equation 23-equation 25 where we bound the derivatives with the Lipschitz continuity in the following inequality:
+
+$$
+\begin{array} { r } { \| \displaystyle \sum _ { l = 1 } ^ { N } \nabla _ { W _ { 1 , j , \cdot } } f _ { l } ( X _ { l } : \theta ^ { ( n ) } , \lambda ^ { ( n ) } ) \| \le 2 N \bar { L } M . } \end{array}
+$$
+
+Inequality equation 37 is by collecting the bounded terms into a single bound $\tilde { M } _ { \bar { L } , M }$ . Therefore,
+
+$$
+| \tilde { \sigma } _ { j } ^ { ( q ) } - \tilde { \sigma } _ { j } ^ { ( p ) } | \leq \sum _ { m = p } ^ { q - 1 } \tilde { \alpha } ^ { ( m ) } | k | \cdot \left( \tilde { M } _ { \bar { L } , M } \sum _ { n = 1 } ^ { m } \eta ^ { ( n ) } + | \bar { C } | \right) .
+$$
+
+Using the similar methods in deriving equation 28 and equation 29, it can be seen that a set of sufficient conditions ensuring the convergence for $\{ \tilde { \sigma } _ { j } ^ { ( m ) } \}$ is: $\textstyle \sum _ { m = 1 } ^ { \infty } \alpha ^ { ( m ) } < \infty$ and $\begin{array} { r } { \sum _ { m = 1 } ^ { \infty } \sum _ { n = 1 } ^ { m } \alpha ^ { ( m ) } \eta ^ { ( n ) } < \infty } \end{array}$ .
+
+Therefore, the convergence conditions for $\{ \sigma _ { j } ^ { ( m ) } \}$ are the same as for $\{ \mu _ { j } ^ { ( m ) } \}$
+
+It is clear that these lemmas establish the proof of Theorem 7.
+
+# 6.3 CONSEQUENCES OF THEOREM 7
+
+Proposition 17 Under the assumptions of Theorem 7, we have $| \lambda ^ { ( m ) } - \bar { \lambda } | _ { \infty } \leq a _ { m }$ , where
+
+$$
+a _ { m } = M _ { 1 } \sum _ { i = m } ^ { \infty } \sum _ { j = 1 } ^ { i } \alpha ^ { ( i ) } \eta ^ { ( j ) } + M _ { 2 } \sum _ { i = m } ^ { \infty } \alpha ^ { ( i ) } .
+$$
+
+$M _ { 1 }$ and $M _ { 2 }$ are constants.
+
+Proof. For the upper bound of $\sigma _ { j } ^ { ( m ) }$ , by equation 38, we have
+
+$$
+| \tilde { \sigma } _ { j } ^ { ( q ) } - \tilde { \sigma } _ { j } ^ { ( p ) } | \leq \sum _ { m = p } ^ { q - 1 } \tilde { \alpha } ^ { ( m ) } | k | \left( \tilde { M } _ { { \bar { L } } , M } \sum _ { n = 1 } ^ { m } \eta ^ { ( n ) } + | \bar { C } | \right) .
+$$
+
+We define σ˜j := j(1 − α(1))...(1 − α(u))... . Therefore,
+
+$$
+\begin{array} { r l r } {  { \vert \tilde { \sigma } _ { j } - \tilde { \sigma } _ { j } ^ { ( m ) } \vert \leq \sum _ { i = m } ^ { \infty } \tilde { \alpha } ^ { ( i ) } \vert k \vert ( \tilde { M } _ { { \bar { L } } , M } \sum _ { j = 1 } ^ { i } \eta ^ { ( j ) } + \vert \bar { C } \vert ) } } \\ & { } & { \leq \frac { \vert k \vert } { C } \sum _ { i = m } ^ { \infty } \alpha ^ { ( i ) } ( \tilde { M } _ { { \bar { L } } , M } \sum _ { j = 1 } ^ { i } \eta ^ { ( j ) } + \vert \bar { C } \vert ) . } \end{array}
+$$
+
+The first inequality comes by substituting $p$ by $m$ and by taking lim as $q  \infty$ in equation 41. The second inequality comes from equation 30. We then obtain,
+
+$$
+\begin{array} { l } { \displaystyle \left| \sigma _ { j } ^ { ( m ) } - \bar { \sigma } _ { j } \right| \leq \left| \tilde { \sigma } _ { j } ^ { ( m ) } - \tilde { \sigma } _ { j } ^ { ( \infty ) } \right| + \left| \frac { \bar { \sigma } _ { j } } { ( 1 - \alpha ^ { ( 1 ) } ) \dots ( 1 - \alpha ^ { ( m ) } ) } - \tilde { \sigma } _ { j } ^ { ( \infty ) } \right| } \\ { \displaystyle = \left| \tilde { \sigma } _ { j } ^ { ( m ) } - \tilde { \sigma } _ { j } ^ { ( \infty ) } \right| + \left| \frac { \bar { \sigma } _ { j } } { ( 1 - \alpha ^ { ( 1 ) } ) \dots ( 1 - \alpha ^ { ( m ) } ) } - \frac { \bar { \sigma } _ { j } } { ( 1 - \alpha ^ { ( 1 ) } ) \dots ( 1 - \alpha ^ { ( m ) } ) \dots } \right| } \\ { \displaystyle = \left| \tilde { \sigma } _ { j } ^ { ( m ) } - \tilde { \sigma } _ { j } ^ { ( \infty ) } \right| + \bar { \sigma } _ { j } \left| \frac { ( 1 - \alpha ^ { ( m + 1 ) } ) \dots ( 1 - \alpha ^ { ( u ) } ) \dots - 1 } { ( 1 - \alpha ^ { ( 1 ) } ) \dots ( 1 - \alpha ^ { ( u ) } ) \dots } \right| } \\ { \displaystyle \leq \left| \tilde { \sigma } _ { j } ^ { ( m ) } - \tilde { \sigma } _ { j } ^ { ( \infty ) } \right| + \frac { \bar { \sigma } _ { j } } { \mathcal { C } } \left| 1 - ( 1 - \alpha ^ { ( m + 1 ) } ) \dots ( 1 - \alpha ^ { ( u ) } ) \dots \right| } \\ { \displaystyle \leq \left| \tilde { \sigma } _ { j } ^ { ( m ) } - \tilde { \sigma } _ { j } ^ { ( \infty ) } \right| + \frac { \bar { \sigma } _ { j } } { \mathcal { C } } \sum _ { n = m + 1 } ^ { \infty } \alpha ^ { ( n ) } . } \end{array}
+$$
+
+The second inequality is by $( 1 - \alpha ^ { ( 1 ) } ) . . . ( 1 - \alpha ^ { ( m ) } ) < 1$ , the third inequality is by equation 30 and the last inequality can be easily seen by induction. By equation 44, we obtain
+
+$$
+| \bar { \sigma } _ { j } - \sigma _ { j } ^ { ( m ) } | = \operatorname* { l i m } _ { M \to \infty } | \sigma _ { j } ^ { ( M ) } - \sigma _ { j } ^ { ( m ) } | \leq | \tilde { \sigma } _ { j } - \tilde { \sigma } _ { j } ^ { ( m ) } | + \frac { \bar { \sigma _ { j } } } { C } \sum _ { n = m + 1 } ^ { \infty } \alpha ^ { ( n ) } .
+$$
+
+Therefore, we have
+
+$$
+\begin{array} { r l } & { \displaystyle | \bar { \boldsymbol { \sigma } } _ { j } - \boldsymbol { \sigma } _ { j } ^ { ( m ) } | \leq | \tilde { \boldsymbol { \sigma } } _ { j } - \tilde { \boldsymbol { \sigma } } _ { j } ^ { ( m ) } | + \frac { \bar { \boldsymbol { \sigma } } _ { j } } { C } \displaystyle \sum _ { n = m + 1 } ^ { \infty } \alpha ^ { ( n ) } } \\ & { \leq \displaystyle \sum _ { i = m } ^ { \infty } \tilde { \alpha } ^ { ( i ) } | k | \cdot \bigg ( \tilde { M } _ { { \bar { L } } , M } \displaystyle \sum _ { j = 1 } ^ { i } \eta ^ { ( j ) } + | \bar { C } | \bigg ) + \frac { \bar { \boldsymbol { \sigma } } _ { j } } { C } \displaystyle \sum _ { i = m + 1 } ^ { \infty } \alpha ^ { ( i ) } } \\ & { \leq \displaystyle \sum _ { i = m } ^ { \infty } \frac { 1 } { C } \alpha ^ { ( i ) } | k | \cdot \bigg ( \tilde { M } _ { { \bar { L } } , M } \displaystyle \sum _ { j = 1 } ^ { i } \eta ^ { ( j ) } + | \bar { C } | \bigg ) + \frac { \bar { \boldsymbol { \sigma } } _ { j } } { C } \displaystyle \sum _ { i = m + 1 } ^ { \infty } \alpha ^ { ( i ) } } \\ & { \leq \displaystyle \frac { \tilde { M } _ { { \bar { L } } , M } | k | } { C } \sum _ { \sum } ^ { i } \alpha ^ { ( i ) } \eta ^ { ( i ) } + \bigg ( \frac { \bar { \boldsymbol { \sigma } } _ { j } } { C } + \frac { | k | | \bar { C } | } { C } \bigg ) \sum _ { \alpha } ^ { \infty } \alpha ^ { ( i ) } . } \end{array}
+$$
+
+The first inequality is by equation 45, the second inequality is by equation 41, the third inequality is by equation 31 and the fourth inequality is by adding the nonnegative term $\frac { \bar { \sigma } _ { j } } { C } \alpha ^ { ( m ) }$ to the right-hand side.
+
+For the upper bound of $\mu _ { j } ^ { ( m ) }$ , we have
+
+$$
+\left| \mu _ { j } ^ { ( m ) } - \bar { \mu } _ { j } \right| \leq \left| \tilde { \mu } ^ { ( m ) } - \tilde { \mu } ^ { ( \infty ) } \right| + \left| \frac { \bar { \mu } _ { j } } { ( 1 - \alpha ^ { ( 1 ) } ) . . . ( 1 - \alpha ^ { ( m ) } ) } - \tilde { \mu } ^ { ( \infty ) } \right| .
+$$
+
+Let us define ${ \cal A } _ { m } : = \Big | \tilde { \mu } ^ { ( m ) } - \tilde { \mu } ^ { ( \infty ) } \Big |$ and $B _ { m } : = \left| \frac { \bar { \mu } _ { j } } { ( 1 - \alpha ^ { ( 1 ) } ) . . . ( 1 - \alpha ^ { ( m ) } ) } - \tilde { \mu } ^ { ( \infty ) } \right|$ . Recall from Theorem 7 that $\{ \mu _ { j } ^ { ( m ) } \}$ is a Cauchy series, by equation 27, $\begin{array} { r } { | \tilde { \mu } _ { j } ^ { ( p ) } - \tilde { \mu } _ { j } ^ { ( q ) } | \leq \bar { M } _ { \bar { L } , M } \cdot \sum _ { m = p } ^ { q } \sum _ { n = 1 } ^ { m } \alpha ^ { ( m ) } \eta ^ { ( n ) } } \end{array}$ . Therefore, the first term in equation 47 is bounded by
+
+$$
+| \tilde { \mu } _ { j } ^ { ( m ) } - \tilde { \mu } _ { j } ^ { \infty } | \leq \tilde { M } _ { { \bar { L } } , M } \cdot \sum _ { i = m } ^ { \infty } \sum _ { n = 1 } ^ { i } \alpha ^ { ( i ) } \eta ^ { ( n ) } < \infty .
+$$
+
+For the second term in equation 47, recall that ${ \cal C } ~ : = ~ ( 1 - \alpha ^ { ( 1 ) } ) . . . ( 1 - \alpha ^ { ( u ) } ) . . .$ . Then we have $C \cdot \left. \frac { \bar { \mu } _ { j } } { ( 1 - \alpha ^ { ( 1 ) } ) . . . ( 1 - \alpha ^ { ( m ) } ) } - \tilde { \mu } ^ { ( \infty ) } \right. \leq \bar { \mu } _ { j } \sum _ { i = m + 1 } ^ { \infty } \alpha ^ { ( i ) } ,$ where the inequality can be easily seen by induction. Therefore, the second term in equation 47 is bounded by
+
+$$
+\left| \frac { \bar { \mu } _ { j } } { ( 1 - \alpha ^ { ( 1 ) } ) . . . ( 1 - \alpha ^ { ( m ) } ) } - \tilde { \mu } ^ { ( \infty ) } \right| \leq \frac { \bar { \mu } _ { j } } { C } \sum _ { i = m + 1 } ^ { \infty } \alpha ^ { ( i ) } .
+$$
+
+From these we obtain
+
+$$
+\left| \mu _ { j } ^ { ( m ) } - \bar { \mu } _ { j } \right| \leq \tilde { M } _ { \bar { L } , M } \sum _ { i = m } ^ { \infty } \sum _ { n = 1 } ^ { i } \alpha ^ { ( i ) } \eta ^ { ( n ) } + \frac { \bar { \mu } _ { j } } { C } \sum _ { i = m + 1 } ^ { \infty } \alpha ^ { ( i ) } .
+$$
+
+The first inequality is by equation 47 and the second inequality is by equation 48 and equation 49. Combining equation 46 and equation 50, we have that
+
+$$
+| \lambda ^ { ( m ) } - \bar { \lambda } | _ { \infty } \leq M _ { 1 } \sum _ { i = m } ^ { \infty } \sum _ { j = 1 } ^ { i } \alpha ^ { ( i ) } \eta ^ { ( j ) } + M _ { 2 } \sum _ { i = m } ^ { \infty } \alpha ^ { ( i ) } ,
+$$
+
+where $M _ { 1 }$ and $M _ { 2 }$ are constants defined as $\begin{array} { r l r } { M _ { 1 } } & { { } = } & { \operatorname* { m a x } ( \frac { \tilde { M } _ { \bar { L } , M } | k | } { C } , \bar { M } _ { \bar { L } , M } ) } \end{array}$ | , M¯ L,M¯ ) and M2 = $\operatorname* { m a x } ( \frac { \bar { \sigma } _ { j } + | k | | \bar { C } | } { C } , \frac { \bar { \mu } _ { j } } { C } ) .$
+
+Proposition 18 Under the assumptions of Theorem 7,
+
+$$
+\begin{array} { r } { - \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) ^ { T } \cdot \nabla \bar { f } ( \theta ^ { ( m ) } , \lambda ^ { ( m ) } ) \leq - \| \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \| ^ { 2 } + \bar { L } M \sqrt { n _ { 2 } } a _ { m } , } \end{array}
+$$
+
+where $a _ { m }$ is defined in Proposition $^ { 1 7 }$ .
+
+Proof. For simplicity of the proof, let us define $\begin{array} { r } { \boldsymbol { x } ^ { ( m ) } : = \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) , \quad \boldsymbol { y } ^ { ( m ) } : = \nabla \bar { f } ( \theta ^ { ( m ) } , \lambda ^ { ( m ) } ) } \end{array}$ . We have
+
+$$
+\begin{array} { r } { | x ^ { ( m ) } - y ^ { ( m ) } | _ { \infty } \leq \bar { L } \sqrt { n _ { 2 } } \| \lambda ^ { ( m ) } - \bar { \lambda } \| _ { \infty } \leq \bar { L } \sqrt { n _ { 2 } } a _ { m } , } \end{array}
+$$
+
+where $\sqrt { n _ { 2 } }$ is the dimension of $\lambda$ . The second inequality is by Assumption 1 and the fourth inequality is by Proposition 17. Inequality equation 51 implies that for all $m$ and $_ { i }$ , we have $| x _ { i } ^ { ( m ) } - y _ { i } ^ { ( m ) } | \leq \bar { L } \sqrt { n _ { 2 } } a _ { m }$ .
+
+It remains to show
+
+$$
+- \sum _ { i } y _ { i } ^ { ( m ) } x _ { i } ^ { ( m ) } \leq - \sum _ { i } x _ { i } ^ { ( m ) ^ { 2 } } + \bar { L } M \sqrt { n _ { 2 } } a _ { m } , \forall i , m .
+$$
+
+This is established by the following four cases.
+
+1) If x(m)i ≥ $x _ { i } ^ { ( m ) } \geq 0 , x _ { i } ^ { ( m ) } - y _ { i } ^ { ( m ) } \geq 0$ , then $x _ { i } ^ { ( m ) } \leq \bar { L } \sqrt { n _ { 2 } } a _ { m } + y _ { i } ^ { ( m ) }$ . Thus $- x _ { i } ^ { ( m ) } y _ { i } ^ { ( m ) } \leq - x _ { i } ^ { ( m ) ^ { 2 } } + \bar { L } M \sqrt { n _ { 2 } } a _ { m }$ by Proposition 12.
+
+2) If x(i $) , x _ { i } ^ { ( m ) } - y _ { i } ^ { ( m ) } \leq 0 , \mathrm { t h e n ~ } x _ { i } ^ { ( m ) } \leq y _ { i } ^ { ( m ) } , x _ { i } ^ { ( m ) ^ { 2 } } \leq x _ { i } ^ { ( m ) } \cdot y _ { i } ^ { ( m ) } \mathrm { ~ a n d ~ } - x _ { i } ^ { ( m ) } y _ { i } ^ { ( m ) } \leq - x _ { i } ^ { ( m ) ^ { 2 } } .$
+
+3) If $x _ { i } ^ { ( m ) } < 0 , x _ { i } ^ { ( m ) } - y _ { i } ^ { ( m ) } \geq 0$ ) ≥ 0, then x(i $x _ { i } ^ { ( m ) } \geq y _ { i } ^ { ( m ) } , x _ { i } ^ { ( m ) ^ { 2 } } \leq x _ { i } ^ { ( m ) } \cdot y _ { i } ^ { ( m ) }$ and $- x _ { i } ^ { ( m ) } y _ { i } ^ { ( m ) } \leq - x _ { i } ^ { ( m ) ^ { 2 } }$
+
+4) If $x _ { i } ^ { ( m ) } < 0 , x _ { i } ^ { ( m ) } - y _ { i } ^ { ( m ) } \leq 0$ ≤ 0, then y(i $y _ { i } ^ { ( m ) } - x _ { i } ^ { ( m ) } \leq \bar { L } \sqrt { n _ { 2 } } a _ { m }$ , $y _ { i } ^ { ( m ) } x _ { i } ^ { ( m ) } - x _ { i } ^ { ( m ) ^ { 2 } } \geq \bar { L } \sqrt { n _ { 2 } } a _ { m } x _ { i } ^ { ( m ) }$ an d $- y _ { i } ^ { ( m ) } x _ { i } ^ { ( m ) } \leq - x _ { i } ^ { ( m ) ^ { 2 } } - \bar { L } \sqrt { n _ { 2 } } a _ { m } x _ { i } ^ { ( m ) } \leq - x _ { i } ^ { ( m ) ^ { 2 } } + \bar { L } M \sqrt { n _ { 2 } } a _ { m } .$ . The last inequality is by Proposition 12.
+
+All these four cases yield equation 52.
+
+Proposition 19 Under the assumptions of Theorem 7, we have
+
+$$
+\begin{array} { r l } & { \bar { f } ( \theta ^ { ( m + 1 ) } , \bar { \lambda } ) \le \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) - \eta ^ { ( m ) } \| \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \| _ { 2 } ^ { 2 } } \\ & { \quad \quad \quad + \eta ^ { ( m ) } \bar { L } M \sqrt { n _ { 2 } } a _ { m } + \frac { 1 } { 2 } ( \eta ^ { ( m ) } ) ^ { 2 } \cdot N \bar { L } M , } \end{array}
+$$
+
+where $M$ is a constant and $a _ { m }$ is defined in Proposition $^ { 1 7 }$ .
+
+Proof. By Proposition 13,
+
+$$
+f _ { i } ( X _ { i } : \tilde { \theta } , \lambda ) \leq f _ { i } ( X _ { i } : \hat { \theta } , \lambda ) + \nabla f _ { i } ( X _ { i } : \hat { \theta } , \lambda ) ^ { T } ( \tilde { \theta } - \hat { \theta } ) + \frac { 1 } { 2 } \bar { L } \| \tilde { \theta } - \hat { \theta } \| _ { 2 } ^ { 2 } .
+$$
+
+Therefore, we can sum it over the entire training set from $i = 1$ to $N$ to obtain
+
+$$
+\bar { f } ( \tilde { \theta } , \lambda ) \leq \bar { f } ( \hat { \theta } , \lambda ) + \nabla \bar { f } ( \hat { \theta } , \lambda ) ^ { T } ( \tilde { \theta } - \hat { \theta } ) + \frac { N } { 2 } \bar { L } \| \tilde { \theta } - \hat { \theta } \| _ { 2 } ^ { 2 } .
+$$
+
+In Algorithm 1, we define the update of $\theta$ in the following full gradient way:
+
+$$
+\boldsymbol { \theta } ^ { ( m + 1 ) } : = \boldsymbol { \theta } ^ { ( m ) } - \boldsymbol { \eta } ^ { ( m ) } \cdot \sum _ { i = 1 } ^ { N } \cdot \nabla f _ { i } ( X _ { i } : \boldsymbol { \theta } ^ { ( m ) } , \boldsymbol { \lambda } ^ { ( m ) } ) ,
+$$
+
+which implies
+
+$$
+\boldsymbol { \theta } ^ { ( m + 1 ) } - \boldsymbol { \theta } ^ { ( m ) } = - \boldsymbol { \eta } ^ { ( m ) } \cdot \nabla \bar { f } ( \boldsymbol { \theta } ^ { ( m ) } , \lambda ^ { ( m ) } ) .
+$$
+
+By equation 56 we have $\begin{array} { r } { \tilde { \theta } - \hat { \theta } = \theta ^ { ( m + 1 ) } - \theta ^ { ( m ) } = - \eta ^ { ( m ) } \nabla \bar { f } ( \theta ^ { ( m ) } , \lambda ^ { ( m ) } ) } \end{array}$ . We now substitute $\tilde { \theta } : = \theta ^ { ( m + 1 ) }$ , $\hat { \theta } : = \theta ^ { ( m ) }$ and $\lambda : = \bar { \lambda }$ into equation 54 to obtain
+
+$$
+\begin{array} { l } { \displaystyle \bar { f } ( \theta ^ { ( m + 1 ) } , \bar { \lambda } ) } \\ { \displaystyle \le \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) - \eta ^ { ( m ) } \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) ^ { T } \nabla \bar { f } ( \theta ^ { ( m ) } , \lambda ^ { ( m ) } ) + ( \eta ^ { ( m ) } ) ^ { 2 } \cdot \frac { N \bar { L } M } { 2 } } \\ { \displaystyle \le \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) - \eta ^ { ( m ) } \| \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \| _ { 2 } ^ { 2 } + \eta ^ { ( m ) } \bar { L } M \sqrt { n _ { 2 } } a _ { m } } \\ { \displaystyle \quad + \frac { 1 } { 2 } ( \eta ^ { ( m ) } ) ^ { 2 } \cdot N \bar { L } M . } \end{array}
+$$
+
+The first inequality is by plugging equation 56 into equation 54, the second inequality comes from Proposition 12 and the third inequality comes from Proposition 18. 
+
+# 6.4 PROOF OF THEOREM 11
+
+Here we show Theorem 11 as the consequence of Theorem 7 and Lemmas 8, 9 and 10.
+
+# 6.4.1 PROOF OF LEMMA 8
+
+Here we show Lemma 8 as the consequence of Lemmas 20, 21 and 22.
+
+Lemma 20 to ensure $\begin{array} { r } { \sum _ { m = 1 } ^ { \infty } \sum _ { i = m } ^ { \infty } \sum _ { n = 1 } ^ { i } \alpha ^ { ( i ) } \eta ^ { ( n ) } < \infty } \end{array}$ and $\textstyle \sum _ { m = 1 } ^ { \infty } \sum _ { n = m } ^ { \infty } \alpha ^ { ( n ) } < \infty$ is a set of sufficient condition
+
+$$
+\sum _ { m = 1 } ^ { \infty } | \bar { \sigma _ { j } } - \sigma _ { j } ^ { ( m ) } | < \infty , \forall j .
+$$
+
+Proof. By plugging equation 45 and equation 43 into equation 58, we have the following for all $j$ :
+
+$$
+\begin{array} { r l } & { \quad \displaystyle \sum _ { m = 1 } ^ { \infty } \left| \bar { \sigma } _ { j } - \sigma _ { j } ^ { ( m ) } \right| \leq \sum _ { m = 1 } ^ { \infty } \left( | \tilde { \sigma } _ { j } - \tilde { \sigma } _ { j } ^ { ( m ) } | + \frac { \bar { \sigma } _ { j } } { C } \sum _ { n = m + 1 } ^ { \infty } \alpha ^ { ( n ) } \right) } \\ & { \leq \frac { | \boldsymbol { k } | \cdot \tilde { M } _ { \bar { L } , M } } { C } \displaystyle \sum _ { m = 1 } ^ { \infty } \sum _ { i = m } ^ { \infty } \alpha ^ { ( i ) } \sum _ { j = 1 } ^ { i } \eta ^ { ( j ) } + \frac { \bar { \sigma } _ { j } + | \boldsymbol { k } | | \bar { C } | } { C } \sum _ { m = 1 } ^ { \infty } \sum _ { n = m + 1 } ^ { \infty } \alpha ^ { ( n ) } . } \end{array}
+$$
+
+$\begin{array} { r } { \sum _ { m = 1 } ^ { \infty } \sum _ { i = m } ^ { \infty } \sum _ { n = 1 } ^ { i } \alpha ^ { ( i ) } \eta ^ { ( n ) } < \infty } \end{array}$ g coand $\textstyle \sum _ { m = 1 } ^ { \infty } \sum _ { n = m } ^ { \infty } \alpha ^ { ( n ) } < \infty$ ight-hand side of equation 59 to be finite:.
+
+Therefore, we obtain
+
+$$
+\sum _ { m = 1 } ^ { \infty } | \bar { \sigma _ { j } } - \sigma _ { j } ^ { ( m ) } | < \infty , \forall j .
+$$
+
+Lemma 21 Under Assumption 4,
+
+$$
+\sum _ { m = 1 } ^ { \infty } \sum _ { i = m } ^ { \infty } \sum _ { n = 1 } ^ { i } \alpha ^ { ( i ) } \eta ^ { ( n ) } < \infty \quad a n d \quad \sum _ { m = 1 } ^ { \infty } \sum _ { n = m } ^ { \infty } \alpha ^ { ( n ) } < \infty
+$$
+
+is a set of sufficient conditions to ensure
+
+$$
+\operatorname * { l i m } _ { M \to \infty } \operatorname * { s u p } _ { m = 1 } ^ { M } \left| \bar { f } ( \theta ^ { ( m ) } , \lambda ^ { ( m ) } ) - \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \right| < \infty .
+$$
+
+Proof. By Assumption 4, we have
+
+$$
+\| l _ { i } ( x ) - l _ { i } ( y ) \| \leq \hat { M } \| x - y \| \leq \hat { M } \sum _ { i = 1 } ^ { D } | x _ { i } - y _ { i } | .
+$$
+
+By the definition of $f _ { i } ( \cdot )$ , we then have
+
+$$
+\begin{array} { r l } & { \quad \displaystyle \sum _ { m = 1 } ^ { \infty } | \bar { f } ( \theta ^ { ( m ) } , \lambda ^ { ( m ) } ) - \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) | } \\ & { \leq \displaystyle \sum _ { m = 1 } ^ { \infty } \sum _ { i = 1 } ^ { N } | ( \bar { l } _ { i } ( X _ { i } : \theta ^ { ( m ) } , \lambda ^ { ( m ) } ) - l _ { i } ( X _ { i } : \theta ^ { ( m ) } , \bar { \lambda } ) ) | } \\ & { \leq M _ { 2 } \displaystyle \sum _ { m = 1 } ^ { \infty } \sum _ { j = 1 } ^ { D } \sum _ { i = 1 } ^ { N } | \frac { a ( W _ { 1 , j } ^ { ( m ) } , X _ { i } ) - \mu _ { j } ^ { ( m ) } } { \sigma _ { j } ^ { ( m ) } } - \frac { a ( W _ { 1 , j , \bar { j } } ^ { ( m ) } , X _ { i } ) - \bar { \mu } _ { j } } { \sigma _ { j } + \epsilon _ { B } } | } \\ & { \leq M _ { 3 } \displaystyle \sum _ { m = 1 } ^ { \infty } \sum _ { j = 1 } ^ { D } ( \displaystyle \sum _ { i = 1 } ^ { N } | k | | W _ { 1 , j , \bar { j } } ^ { ( m ) } , X _ { i } | | \displaystyle \frac { | \bar { \sigma } _ { j } - \sigma _ { j } ^ { ( m ) } | } { \epsilon _ { B } ^ { 2 } } | + N | \frac { \bar { \mu } _ { j } } { \bar { \sigma } _ { j } + \epsilon _ { B } } - \frac { \mu _ { j } ^ { ( m ) } } { \sigma _ { j } ^ { ( m ) } + \epsilon _ { B } } | ) . } \end{array}
+$$
+
+The first inequality is by the Cauchy-Schwarz inequality, and the second one is by equation 60. To show the finiteness of equation 64, we only need to show the following two statements:
+
+and
+
+$$
+\begin{array} { l } { { \displaystyle \sum _ { m = 1 } ^ { \infty } \sum _ { i = 1 } ^ { N } | k | | W _ { 1 , j , \cdot } ^ { ( m ) } X _ { i } | | | \frac { \bar { \sigma } _ { j } - \sigma _ { j } ^ { ( m ) } } { \epsilon _ { B } ^ { 2 } } | < \infty , \forall j } } \\ { { \displaystyle \sum _ { m = 1 } ^ { \infty } | \frac { \bar { \mu } _ { j } } { \bar { \sigma } _ { j } + \epsilon _ { B } } - \frac { \mu _ { j } ^ { ( m ) } } { \sigma _ { j } ^ { ( m ) } + \epsilon _ { B } } | < \infty , \forall j . } } \end{array}
+$$
+
+Proof of equation $6 5$ : For all $j$ we have
+
+$$
+\begin{array} { r l } & { \quad \displaystyle \sum _ { m = 1 } ^ { \infty } \sum _ { i = 1 } ^ { N } | k | | W _ { 1 , j , \cdot } ^ { ( m ) } X _ { i } | \left| \frac { \bar { \sigma } _ { j } - \sigma _ { j } ^ { ( m ) } } { \epsilon _ { B } ^ { 2 } } \right| } \\ & { \leq \displaystyle \sum _ { m = 1 } ^ { \infty } | k | N D M \operatorname* { m a x } _ { i } \| X _ { i } \| \frac { 1 } { \epsilon _ { B } ^ { 2 } } \left| \bar { \sigma } _ { j } - \sigma _ { j } ^ { ( m ) } \right| } \\ & { = | k | N D M \operatorname* { m a x } _ { i } \| X _ { i } \| \frac { 1 } { \epsilon _ { B } ^ { 2 } } \sum _ { m = 1 } ^ { \infty } \left| \bar { \sigma } _ { j } - \sigma _ { j } ^ { ( m ) } \right| . } \end{array}
+$$
+
+The inequality comes from $| W _ { 1 , j , \cdot } ^ { ( m ) } X _ { i } | \leq D M \| X _ { i } \| _ { 2 }$ , where $D$ is the dimension of $X _ { i }$ and $M$ is the elementwise upper bound for $W _ { 1 , j , \cdot } ^ { ( m ) }$ in Assumption 2.
+
+Finally, we invoke Lemma 14 to assert that $\begin{array} { r } { \sum _ { m = 1 } ^ { \infty } \bigg | \bar { \sigma } _ { j } - \sigma _ { j } ^ { ( m ) } \bigg | } \end{array}$ is finite.
+
+Proof of equation $^ { 6 6 }$ : For all $j$ we have
+
+$$
+\begin{array} { l } { { \displaystyle \sum _ { m = 1 } ^ { \infty } \left| \frac { \bar { \mu } _ { j } } { \bar { \sigma } _ { j } + \epsilon _ { B } } - \frac { \mu _ { j } ^ { ( m ) } } { \sigma _ { j } ^ { ( m ) } + \epsilon _ { B } } \right| } } \\ { { \displaystyle \leq \sum _ { m = 1 } ^ { \infty } \left| \frac { \bar { \mu } _ { j } } { \bar { \sigma } _ { j } + \epsilon _ { B } } - \frac { \mu _ { j } ^ { ( m ) } } { \bar { \sigma } _ { j } + \epsilon _ { B } } \right| + \sum _ { m = 1 } ^ { \infty } \left| \frac { \mu _ { j } ^ { ( m ) } } { \bar { \sigma } _ { j } + \epsilon _ { B } } - \frac { \mu _ { j } ^ { ( m ) } } { \sigma _ { j } ^ { ( m ) } + \epsilon _ { B } } \right| . } } \end{array}
+$$
+
+The first term in equation 68 is finite since $\{ \mu _ { j } ^ { ( m ) } \}$ is a Cauchy series. For the second term, we know that there exists a constant $M$ such that for all $m \geq M$ , $\mu _ { j } ^ { ( m ) } \leq \bar { \mu } + 1$ . This is also by the fact that $\{ \mu _ { j } ^ { ( m ) } \}$ is a Cauchy series and it converges to $\bar { \mu }$ . Therefore, the second term in equation 68 becomes
+
+$$
+\begin{array} { r l } & { \displaystyle \sum _ { m = 1 } ^ { M - 1 } \left| \frac { \mu _ { j } ^ { ( m ) } } { \bar { \sigma } _ { j } + \epsilon _ { B } } - \frac { \mu _ { j } ^ { ( m ) } } { \sigma _ { j } ^ { ( m ) } + \epsilon _ { B } } \right| + \displaystyle \sum _ { m = M } ^ { \infty } \left| \frac { \mu _ { j } ^ { ( m ) } } { \bar { \sigma } _ { j } + \epsilon _ { B } } - \frac { \mu _ { j } ^ { ( m ) } } { \sigma _ { j } ^ { ( m ) } + \epsilon _ { B } } \right| } \\ & { \leq \displaystyle \sum _ { m = 1 } ^ { M - 1 } \left| \frac { \mu _ { j } ^ { ( m ) } } { \bar { \sigma } _ { j } + \epsilon _ { B } } - \frac { \mu _ { j } ^ { ( m ) } } { \sigma _ { j } ^ { ( m ) } + \epsilon _ { B } } \right| + \displaystyle \sum _ { m = M } ^ { \infty } ( \bar { \mu } + 1 ) \left| \frac { 1 } { \bar { \sigma } _ { j } + \epsilon _ { B } } - \frac { 1 } { \sigma _ { j } ^ { ( m ) } + \epsilon _ { B } } \right| . } \end{array}
+$$
+
+Noted that function $f ( { \boldsymbol { \sigma } } ) = \frac { 1 } { { \boldsymbol { \sigma } } + { \epsilon _ { B } } }$ is Lipschitz continuous since its gradient is bounded by $\frac { 1 } { \epsilon _ { B } ^ { 2 } }$ Therefore we can choose $\frac { 1 } { \epsilon _ { B } ^ { 2 } }$ as the Lipschitz constant for $f ( \sigma )$ . We then have the following inequality:
+
+$$
+\left| \frac { 1 } { \bar { \sigma } _ { j } + \epsilon _ { B } } - \frac { 1 } { \sigma _ { j } ^ { ( m ) } + \epsilon _ { B } } \right| \leq \frac { 1 } { \epsilon _ { B } ^ { 2 } } | \bar { \sigma } _ { j } - \sigma _ { j } ^ { ( m ) } | .
+$$
+
+Plugging equation 70 into equation 69, we obtain
+
+$$
+\begin{array} { r l } & { ~ \displaystyle \sum _ { m = 1 } ^ { M - 1 } \left| \frac { \mu _ { j } ^ { ( m ) } } { \bar { \sigma } _ { j } + \epsilon _ { B } } - \frac { \mu _ { j } ^ { ( m ) } } { \sigma _ { j } ^ { ( m ) } + \epsilon _ { B } } \right| + \displaystyle \sum _ { m = M } ^ { \infty } ( \bar { \mu } + 1 ) \left| \frac { 1 } { \bar { \sigma } _ { j } + \epsilon _ { B } } - \frac { 1 } { \sigma _ { j } ^ { ( m ) } + \epsilon _ { B } } \right| } \\ & { \le \displaystyle \sum _ { m = 1 } ^ { M - 1 } \left| \frac { \mu _ { j } ^ { ( m ) } } { \bar { \sigma } _ { j } + \epsilon _ { B } } - \frac { \mu _ { j } ^ { ( m ) } } { \sigma _ { j } ^ { ( m ) } + \epsilon _ { B } } \right| + \displaystyle \sum _ { m = M } ^ { \infty } \frac { ( \bar { \mu } + 1 ) } { \epsilon _ { B } ^ { 2 } } | \bar { \sigma } _ { j } - \sigma _ { j } ^ { ( m ) } | , } \end{array}
+$$
+
+where the first term is finite by the fact that $M$ is a finite constant. We have shown the condition for the second term to be finite in Lemma 20. Therefore,
+
+$$
+\sum _ { m = 1 } ^ { \infty } \left| \frac { \bar { \mu } _ { j } } { \bar { \sigma } _ { j } + \epsilon _ { B } } - \frac { \mu _ { j } ^ { ( m ) } } { \sigma _ { j } ^ { ( m ) } + \epsilon _ { B } } \right| < \infty , \forall j .
+$$
+
+By equation 65 and equation 66, we have that the right-hand side of equation 64 is finite. It means that the left-hand side of equation 64 is finite. Thus,
+
+$$
+\sum _ { m = 1 } ^ { \infty } \left| \bar { f } ( \theta ^ { ( m ) } , \lambda ^ { ( m ) } ) - \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \right| < \infty .
+$$
+
+Lemma 22 If
+
+then
+
+$$
+\begin{array} { c } { { \displaystyle \sum _ { m = 1 } ^ { \infty } \sum _ { i = m } ^ { \infty } \sum _ { n = 1 } ^ { i } \alpha ^ { ( i ) } \eta ^ { ( n ) } < \infty \quad a n d \quad \displaystyle \sum _ { m = 1 } ^ { \infty } \sum _ { n = m } ^ { \infty } \alpha ^ { ( n ) } < \infty , } } \\ { { \displaystyle \operatorname* { l i m } _ { M \to \infty } \sum _ { m = 1 } ^ { M } \eta ^ { ( m ) } \| \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \| _ { 2 } ^ { 2 } < \infty . } } \end{array}
+$$
+
+Proof. For simplicity of the proof, we define
+
+$$
+\begin{array} { c } { { \displaystyle T ^ { ( M ) } : = \sum _ { m = 1 } ^ { M } \eta ^ { ( m ) } \| \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \| _ { 2 } ^ { 2 } , } } \\ { { \displaystyle O ^ { ( m ) } : = \bar { f } ( \theta ^ { ( m + 1 ) } , \lambda ^ { ( m + 1 ) } ) - \bar { f } ( \theta ^ { ( m ) } , \lambda ^ { ( m ) } ) , } } \\ { { \Delta _ { 1 } ^ { ( m + 1 ) } : = \bar { f } ( \theta ^ { ( m + 1 ) } , \lambda ^ { ( m + 1 ) } ) - \bar { f } ( \theta ^ { ( m + 1 ) } , \bar { \lambda } ) , } } \\ { { \displaystyle \Delta _ { 2 } ^ { ( m ) } : = \bar { f } ( \theta ^ { ( m + 1 ) } , \bar { \lambda } ) - \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) , } } \end{array}
+$$
+
+where $\bar { \lambda }$ is the converged value of $\lambda$ in Theorem 7. Therefore,
+
+$$
+O ^ { ( m ) } = \Delta _ { 1 } ^ { ( m + 1 ) } + \Delta _ { 1 } ^ { ( m ) } + \Delta _ { 2 } ^ { ( m ) } \leq | \Delta _ { 1 } ^ { ( m + 1 ) } | + | \Delta _ { 1 } ^ { ( m ) } | + \Delta _ { 2 } ^ { ( m ) } .
+$$
+
+By Proposition 19,
+
+$$
+\Delta _ { 2 } ^ { ( m ) } \leq - \eta ^ { ( m ) } \| \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \| _ { 2 } ^ { 2 } + \eta ^ { ( m ) } \bar { L } M \sqrt { n _ { 2 } } a _ { m } + \frac { 1 } { 2 } ( \eta ^ { ( m ) } ) ^ { 2 } \cdot N \bar { L } M .
+$$
+
+We sum the inequality equation 72 from 1 to $K$ with respect to $m$ and plug equation 73 into it to obtain
+
+$$
+\begin{array} { l } { \displaystyle \sum _ { m = 1 } ^ { K } O ^ { ( m ) } \le \displaystyle \sum _ { m = 1 } ^ { K } | \Delta _ { 1 } ^ { ( m + 1 ) } | + \displaystyle \sum _ { m = 1 } ^ { K } | \Delta _ { 1 } ^ { ( m ) } | - \displaystyle \sum _ { m = 1 } ^ { K } \{ \eta ^ { ( m ) } \| \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \| _ { 2 } ^ { 2 } \} } \\ { \displaystyle \qquad + \displaystyle \sum _ { m = 1 } ^ { K } \eta ^ { ( m ) } \bar { L } M \sqrt { n _ { 2 } } a _ { m } + \displaystyle \sum _ { m = 1 } ^ { K } \{ \frac { 1 } { 2 } ( \eta ^ { ( m ) } ) ^ { 2 } N \bar { L } M \} } \\ { \displaystyle \qquad = \sum _ { m = 1 } ^ { K } | \Delta _ { 1 } ^ { ( m + 1 ) } | + \displaystyle \sum _ { m = 1 } ^ { K } | \Delta _ { 1 } ^ { ( m ) } | - T ^ { ( K ) } } \\ { \displaystyle \qquad + \bar { L } ^ { 2 } \sqrt { n _ { 2 } } \cdot \displaystyle \sum _ { m = 1 } ^ { K } \eta ^ { ( m ) } a _ { m } + \displaystyle \sum _ { m = 1 } ^ { K } \{ \frac { 1 } { 2 } ( \eta ^ { ( m ) } ) ^ { 2 } N \bar { L } M \} . } \end{array}
+$$
+
+From this, we have:
+
+$$
+\begin{array} { r l } { \displaystyle \operatorname* { l i m } _ { K \to \infty } T ^ { ( K ) } \le \displaystyle \operatorname* { l i m } _ { K \to \infty } \frac { 1 } { c _ { 1 } } ( \bar { f } ( \theta ^ { ( K ) } , \lambda ^ { ( K ) } ) - \bar { f } ( \theta ^ { ( 1 ) } , \lambda ^ { ( 1 ) } ) ) } \\ { \displaystyle \qquad + \operatorname* { l i m } _ { K \to \infty } \frac { 1 } { c _ { 1 } } \sum _ { m = 1 } ^ { K } ( | \Delta _ { 1 } ^ { ( m + 1 ) } | + | \Delta _ { 1 } ^ { ( m ) } | ) } \\ { \displaystyle \qquad + \operatorname* { l i m } _ { K \to \infty } \bar { L } ^ { 2 } \sqrt { n _ { 2 } } \sum _ { m = 1 } ^ { K } \eta ^ { ( m ) } a _ { m } } \\ { \displaystyle \qquad + \operatorname* { l i m } _ { K \to \infty } \frac { N \bar { L } K } { 2 c _ { 1 } } \sum _ { m = 1 } ^ { K } \eta ^ { ( m ) ^ { 2 } } . } \end{array}
+$$
+
+Next we show that each of the four terms in the right-hand side of equation 75 is finite, respectively. For the first term,
+
+$$
+\operatorname* { l i m } _ { K \to \infty } \operatorname* { s u p } _ { c _ { 1 } } \bigl ( \bar { f } ( \theta ^ { ( K ) } , \lambda ^ { ( K ) } ) - \bar { f } ( \theta ^ { ( 1 ) } , \lambda ^ { ( 1 ) } ) \bigr ) < \infty
+$$
+
+is by the fact that the parameters $\{ \theta , \lambda \}$ are in compact sets, which implies that the image of $f _ { i } ( \cdot )$ is in a bounded set.
+
+For the second term, we showed its finiteness in Lemma 21.
+
+For the third term, by equation 42, we have
+
+$$
+\begin{array} { r l } {  { \operatorname* { l i m s u p } _ { \kappa \to \infty } \displaystyle \sum _ { m = 1 } ^ { \kappa } \eta ^ { ( m ) } a _ { m } } } \\ & { = \operatorname* { l i m s u p } _ { \kappa \to \infty } \displaystyle \sum _ { m = 1 } ^ { \kappa } \eta ^ { ( m ) } ( K _ { 1 } \sum _ { i = m } ^ { \infty } \sum _ { j = 1 } ^ { i } \alpha ^ { ( i ) } \eta ^ { ( j ) } + K _ { 2 } \sum _ { i = m } ^ { \infty } \alpha ^ { ( i ) } ) } \\ & { = K _ { 1 } \operatorname* { l i m s u p } _ { \kappa \to \infty } \displaystyle \sum _ { m = 1 } ^ { \kappa } \eta ^ { ( m ) } ( \sum _ { i = m } ^ { \infty } \sum _ { j = 1 } ^ { i } \alpha ^ { ( i ) } \eta ^ { ( j ) } ) + K _ { 2 } \operatorname* { l i m s u p } _ { \kappa \to \infty } \displaystyle \sum _ { m = 1 } ^ { \kappa } \eta ^ { ( m ) } \sum _ { i = m } ^ { \infty } \alpha ^ { ( i ) } . } \end{array}
+$$
+
+The right-hand side of equation 77 is finite because
+
+$$
+\sum _ { m = 1 } ^ { \infty } \eta ^ { ( m ) } \left( \sum _ { i = m } ^ { \infty } \sum _ { j = 1 } ^ { i } \alpha ^ { ( i ) } \eta ^ { ( j ) } \right) < \sum _ { m = 1 } ^ { \infty } \left( \sum _ { i = m } ^ { \infty } \sum _ { j = 1 } ^ { i } \alpha ^ { ( i ) } \eta ^ { ( j ) } \right) < \infty
+$$
+
+and
+
+$$
+\sum _ { m = 1 } ^ { \infty } \eta ^ { ( m ) } \sum _ { i = m } ^ { \infty } \alpha ^ { ( i ) } < \sum _ { m = 1 } ^ { \infty } \sum _ { i = m } ^ { \infty } \alpha ^ { ( i ) } < \infty .
+$$
+
+The second inequalities in equation 78 and equation 79 come from the stated assumptions of this lemma.
+
+For the fourth term,
+
+$$
+\operatorname* { l i m } _ { K \to \infty } \frac { N \bar { L } M } { 2 c } \sum _ { m = 1 } ^ { K } \eta ^ { ( m ) ^ { 2 } } < \infty
+$$
+
+holds, because we have $\begin{array} { r l r } { \sum _ { m = 1 } ^ { \infty } ( \eta ^ { ( m ) } ) ^ { 2 } } & { { } < } & { \infty } \end{array}$ in Assumption 3. Therefore, $T ^ { ( \infty ) } =$ $\begin{array} { r } { \sum _ { m = 1 } ^ { \infty } \eta ^ { ( m ) } \| \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \| _ { 2 } ^ { 2 } < \infty } \end{array}$ holds.
+
+In Lemmas 20, 21 and 22, we show that $\{ \sigma ^ { ( m ) } \}$ and $\{ \mu ^ { ( m ) } \}$ are Cauchy series, hence Lemma 8 holds.
+
+# 6.4.2 PROOF OF LEMMA 9
+
+This proof is similar to the the proof by Bertsekas $\&$ Tsitsiklis (2000).
+
+Proof. By Theorem 8, we have
+
+$$
+\operatorname* { l i m } _ { M \to \infty } \sum _ { m = 1 } ^ { M } \eta ^ { ( m ) } \| \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \| _ { 2 } ^ { 2 } < \infty .
+$$
+
+If there exists a $\epsilon > 0$ and an integer $\bar { m }$ such that
+
+$$
+\| \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \| _ { 2 } \geq \epsilon
+$$
+
+for all $m \geq { \bar { m } }$ , we would have
+
+$$
+\operatorname* { l i m i n f } _ { M \to \infty } \sum _ { m = \bar { m } } ^ { M } \eta ^ { ( m ) } \| \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \| _ { 2 } ^ { 2 } \geq \operatorname* { l i m i n f } _ { M \to \infty } \epsilon ^ { 2 } \sum _ { m = \bar { m } } ^ { M } \eta ^ { ( m ) } = \infty
+$$
+
+which contradicts equation 81. Therefore, $\operatorname* { l i m } _ { m \to \infty } \operatorname* { i n f } _ { } \| \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \| _ { 2 } = 0$
+
+# 6.4.3 PROOF OF LEMMA 10
+
+Lemma 23 Let $Y _ { t } , W , t$ and $Z _ { t }$ be three sequences such that $W _ { t }$ is nonnegative for all t. Assume that
+
+$$
+Y _ { t + 1 } \le Y _ { t } - W _ { t } + Z _ { t } , \quad t = 0 , 1 , . . . ,
+$$
+
+and that the series $\textstyle \sum _ { t = 0 } ^ { T } Z _ { t }$ converges as $T \to \infty$ . Then either $Y _ { t }  \infty$ or else $Y _ { t }$ converges to a finite value and $\textstyle \sum _ { t = 0 } ^ { \infty } W _ { t } < \infty$ .
+
+This lemma has been proven by Bertsekas & Tsitsiklis (2000).
+
+Lemma 24 When
+
+$$
+\sum _ { m = 1 } ^ { \infty } \sum _ { i = m } ^ { \infty } \sum _ { n = 1 } ^ { i } \alpha ^ { ( i ) } \eta ^ { ( n ) } < \infty \quad a n d \quad \sum _ { m = 1 } ^ { \infty } \sum _ { n = m } ^ { \infty } \alpha ^ { ( n ) } < \infty ,
+$$
+
+it follows that $\bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } )$ converge to a finite value.
+
+Proof. By Proposition 19, we have
+
+$$
+\begin{array} { r l } & { \bar { f } ( \theta ^ { ( m + 1 ) } , \bar { \lambda } ) \le \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) - \eta ^ { ( m ) } \| \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \| _ { 2 } ^ { 2 } } \\ & { \qquad + \eta ^ { ( m ) } \bar { L } M \sqrt { n _ { 2 } } a _ { m } + \displaystyle \frac 1 2 ( \eta ^ { ( m ) } ) ^ { 2 } \cdot N \bar { L } M . } \end{array}
+$$
+
+L $\mathfrak { a } \mathfrak { t } Y ^ { ( m ) } : = \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) , \index { W ^ { ( m ) } } : = \eta ^ { ( m ) } \| \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \| _ { 2 } ^ { 2 } \mathrm { a n d } Z ^ { ( m ) } : = \eta ^ { ( m ) } \bar { L } M \sqrt { n _ { 2 } } a _ { m } + \frac { 1 } { \gamma } ( \eta ^ { ( m ) } ) ^ { 2 } \cdot N \bar { L } M .$ By equation 10 and equation 77- equation 79, it is easy to see that $\textstyle \sum _ { m = 0 } ^ { M } Z ^ { ( m ) }$ converges as $M  \infty$ . Therefore, by Lemma 23, $Y ^ { ( m ) }$ converges to a finite value. The infinite case can not occur in our setting due to Assumptions 1 and 2. 
+
+# Lemma 25 If
+
+$$
+\begin{array} { l } { { \sum _ { m = 1 } ^ { \infty } \sum _ { i = m } ^ { \infty } \sum _ { n = 1 } ^ { i } \alpha ^ { ( i ) } \eta ^ { ( n ) } < \infty \quad a n d \quad \sum _ { m = 1 } ^ { \infty } \sum _ { n = m } ^ { \infty } \alpha ^ { ( n ) } < \infty , } } \\ { { t h e n \underset { m  \infty } { \operatorname* { l i m } } \| \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \| _ { 2 } = 0 . } } \end{array}
+$$
+
+Proof. To show that $\operatorname* { l i m } _ { m \to \infty } \| \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \| _ { 2 } = 0$ , assume the contrary; that is,
+
+$$
+\operatorname* { l i m } _ { m \to \infty } \operatorname* { s u p } _ { \mathbf { \delta } } \| \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \| _ { 2 } > 0 .
+$$
+
+Then there exists an $\epsilon > 0$ such that $\| \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \| < \epsilon / 2$ for infinitely many $m$ and also $\| \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \| > \epsilon$ for infinitely many $m$ . Therefore, there is an infinite subset of integers $\mathbb { M }$ , such that for each $m \in \mathbb { M }$ , there exists an integer $q ( m ) > m$ such that
+
+$$
+\begin{array} { r l } & { \quad \| \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \| < \epsilon / 2 , } \\ & { \| \nabla \bar { f } ( \theta ^ { ( i ( m ) ) } , \bar { \lambda } ) \| > \epsilon , } \\ & { \epsilon / 2 \leq \| \nabla \bar { f } ( \theta ^ { ( i ) } , \bar { \lambda } ) \| \leq \epsilon , } \\ & { \quad \quad \operatorname { i f } m < i < q ( m ) . } \end{array}
+$$
+
+From $\| \nabla \bar { f } ( \theta ^ { ( m + 1 ) } , \bar { \lambda } ) \| - \| \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \| \leq \bar { L } \eta ^ { ( m ) } \| \nabla \bar { f } ( \theta ^ { ( m ) } , \lambda ^ { ( m ) } ) \|$ , it follows that for all $m \in \mathbb { M }$ that are sufficiently large so that $\bar { L } \eta ^ { ( m ) } < \epsilon / 4$ , we have
+
+$$
+\epsilon / 4 \leq \| \nabla \bar { f } ( \theta ^ { ( m ) } , \lambda ^ { ( m ) } ) \| .
+$$
+
+Otherwise the condition $\epsilon / 2 \leq \| \nabla \bar { f } ( \theta ^ { ( m + 1 ) } , \bar { \lambda } ) \|$ would be violated. Without loss of generality, we assume that the above relations as well as equation 57 hold for all $m \in \mathbb { M }$ . With the above observations, we have for all $m \in \mathbb { M }$ ,
+
+$$
+\begin{array} { r l } & { \frac { \epsilon } { 2 } \leq \| \nabla \bar { f } ( \theta ^ { q ( m ) } , \bar { \lambda } ) \| - \| \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \| \leq \bar { L } \| \theta ^ { q ( m ) } - \theta ^ { ( m ) } \| } \\ & { \leq \bar { L } \displaystyle \sum _ { i = m } ^ { q ( m ) - 1 } \eta ^ { ( i ) } ( \| \nabla \bar { f } ( \theta ^ { ( i ) } , \bar { \lambda } ) \| + \| \nabla \bar { f } ( \theta ^ { ( i ) } , \lambda ^ { ( i ) } ) - \nabla \bar { f } ( \theta ^ { ( i ) } , \bar { \lambda } ) \| ) } \\ & { = \bar { L } \displaystyle \sum _ { i = m } ^ { q ( m ) - 1 } \eta ^ { ( i ) } + \bar { L } ^ { 2 } \sqrt { n _ { 2 } } M _ { 1 } \displaystyle \sum _ { i = m } ^ { q ( m ) - 1 } \eta ^ { ( i ) } \displaystyle \sum _ { j = m } ^ { \infty } \sum _ { k = 1 } ^ { j } \alpha ^ { ( j ) } \eta ^ { ( k ) } } \\ & { + \bar { L } ^ { 2 } \sqrt { n _ { 2 } } M _ { 2 } \displaystyle \sum _ { i = m } ^ { q ( m ) - 1 } \eta ^ { ( i ) } \displaystyle \sum _ { j = m } ^ { \infty } \alpha ^ { ( j ) } } \end{array}
+$$
+
+The first inequality is by equation 86 and the third one is by the Lipschitz condition assumption. The seventh one is by equation 51. By equation 12, we have for all $m \in \mathbb { M }$ ,
+
+and
+
+$$
+\begin{array} { r l } {  { \sum _ { i = m } ^ { q ( m ) - 1 } \eta ^ { ( i ) } \sum _ { j = m } ^ { \infty } \sum _ { k = 1 } ^ { j } \alpha ^ { ( j ) } \eta ^ { ( k ) } < \sum _ { i = 1 } ^ { \infty } \sum _ { j = i } ^ { \infty } \sum _ { k = 1 } ^ { j } \alpha ^ { ( j ) } \eta ^ { ( k ) } < \infty } } \\ & { \underset { i = m } { \overset { q ( m ) - 1 } { \sum } } \ \eta ^ { ( i ) } \sum _ { j = m } ^ { \infty } \alpha ^ { ( j ) } < \sum _ { i = 1 } ^ { \infty } \sum _ { j = i } ^ { \infty } \alpha ^ { ( j ) } < \infty . } \end{array}
+$$
+
+It is fore, $\left\{ \alpha _ { i } \right\}$ $\textstyle \sum _ { i = 1 } ^ { \infty } \alpha _ { i } < \infty$ $M \to \infty$ P∞i=M αi = 0 . There-rom this $\begin{array} { r } { \underset { m  \infty } { \operatorname* { l i m } \operatorname* { i n f } } \sum _ { i = m } ^ { q ( m ) - 1 } \eta ^ { ( i ) } \sum _ { j = m } ^ { \infty } \sum _ { k = 1 } ^ { j } \alpha ^ { ( j ) } \eta ^ { ( k ) } = 0 } \end{array}$ $\begin{array} { r } { \underset { m  \infty } { \operatorname* { l i m } \operatorname* { i n f } } \sum _ { i = m } ^ { q ( m ) - 1 } \eta ^ { ( i ) } \sum _ { j = m } ^ { \infty } \alpha ^ { ( j ) } = 0 } \end{array}$ it follows that
+
+$$
+\operatorname* { l i m } _ { m \to \infty } \sum _ { i = m } ^ { q ( m ) - 1 } \eta ^ { ( i ) } \ge \frac { 1 } { 2 \bar { L } } .
+$$
+
+By equation 51 and equation 87, if we pick $m \in \mathbb { M }$ such that $L \sqrt { n _ { 2 } } a _ { m } \leq \frac { \epsilon } { 8 }$ , we have $\| \nabla \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) \| \ge \frac { \epsilon } { 8 }$ Using equation 57, we observe that
+
+$$
+\leq \bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } ) - c _ { 1 } \left( \frac { \epsilon } { 8 } \right) ^ { 2 } \sum _ { i = m } ^ { q ( m ) - 1 } \eta ^ { ( i ) } + \frac { 1 } { 2 } \cdot N \bar { L } M \sum _ { i = m } ^ { q ( m ) - 1 } ( \eta ^ { ( i ) } ) ^ { 2 } , \forall m \in \mathbb { M } ,
+$$
+
+where the second inequality is by equation 87. By Lemma 24, $\bar { f } ( \theta ^ { q ( m ) } , \bar { \lambda } )$ and $\bar { f } ( \theta ^ { ( m ) } , \bar { \lambda } )$ converge to the same finite value. Using this convergence result and the assumption $\textstyle \sum _ { m = 0 } ^ { \infty } ( \eta ^ { ( m ) } ) ^ { 2 } < \infty$ , this relation implies that
+
+$\operatorname* { l i m } _ { m \to \infty , m \in \mathbb { M } } \sum _ { i = m } ^ { q ( m ) - 1 } \eta ^ { ( i ) } = 0$ and contradicts equation 91.
+
+By Lemmas 23, 24 and 25, we show that Theorem 11 holds.
+
+# 6.5 DISCUSSIONS OF CONDITIONS FOR STEPSIZES
+
+Here we discuss the actual conditions for $\eta ^ { ( m ) }$ and $\alpha ^ { ( m ) }$ to satisfy the assumptions of Theorem 7 and Lemma 8. We only consider the cases $\begin{array} { r } { \eta ^ { ( m ) } = \frac { 1 } { m ^ { k } } } \end{array}$ and α(m) $\alpha ^ { ( m ) } \ = \ \frac { 1 } { m ^ { h } }$ , but the same analysis applies to the cases $\begin{array} { r } { \eta ^ { ( m ) } = { \cal O } ( \frac { 1 } { m ^ { k } } ) } \end{array}$ and $\begin{array} { r } { \alpha ^ { ( m ) } = { O } \left( \frac { 1 } { m h } \right) } \end{array}$ .
+
+# 6.6 ASSUMPTIONS OF THEOREM 7
+
+For the assumptions of Theorem 7, the first condition $\textstyle \sum _ { m = 1 } ^ { \infty } \alpha ^ { ( m ) } < \infty$ requires $h > 1$ . Besides, the second condition
+
+$$
+\sum _ { m = 1 } ^ { \infty } \sum _ { n = 1 } ^ { m } \alpha ^ { ( m ) } \eta ^ { ( n ) } \approx \frac { 1 } { h - 1 } \sum _ { n = 1 } ^ { \infty } \eta ^ { ( n ) } \frac { 1 } { n ^ { h - 1 } } = \frac { 1 } { h - 1 } \sum _ { n = 1 } ^ { \infty } \frac { 1 } { n ^ { k + h - 1 } } < \infty
+$$
+
+requires $k + h > 2$ . The approximation comes from the fact that for every $p > 1$ , we have
+
+$$
+\sum _ { k = n } ^ { \infty } k ^ { - p } \approx \int _ { k = n } ^ { \infty } k ^ { - p } d x = \left. { \frac { 1 } { 1 - p } } x ^ { 1 - p } \right| _ { n } ^ { \infty } = { \frac { 1 } { p - 1 } } { \frac { 1 } { n ^ { p - 1 } } } .
+$$
+
+Since $k \geq 1$ due to Assumption 3, we conclude that $k + h > 2$ . Therefore, the conditions for $\eta ^ { ( m ) }$ and $\alpha ^ { ( m ) }$ to satisfy the assumptions of Theorem 7 are $h > 1$ and $k \geq 1$ .
+
+# 6.7 ASSUMPTIONS OF LEMMA 8
+
+For the assumptions of Theorem 7, the first condition
+
+$$
+\sum _ { m = 1 } ^ { \infty } \sum _ { n = m } ^ { \infty } \alpha ^ { ( n ) } \approx \sum _ { m = 1 } ^ { \infty } \frac { 1 } { m ^ { h - 1 } } < \infty
+$$
+
+requires $h > 2$ .
+
+Besides, the second condition is
+
+$$
+\sum _ { m = 1 } ^ { \infty } \sum _ { i = m } ^ { \infty } \sum _ { n = 1 } ^ { i } \alpha ^ { ( i ) } \eta ^ { ( n ) } = \sum _ { m = 1 } ^ { \infty } \sum _ { i = m } ^ { \infty } \alpha ^ { ( i ) } \sum _ { n = 1 } ^ { i } \eta ^ { ( n ) } \le C \sum _ { m = 1 } ^ { \infty } \sum _ { i = m } ^ { \infty } \alpha ^ { ( i ) } < \infty .
+$$
+
+The inequality holds because for any $p > 1$ , we have
+
+$$
+\sum _ { k = 1 } ^ { n } k ^ { - p } \approx \int _ { k = 1 } ^ { n } k ^ { - p } d k = \left. { \frac { 1 } { 1 - p } } k ^ { 1 - p } \right| _ { 1 } ^ { n } = { \frac { 1 } { p - 1 } } ( 1 - n ^ { 1 - p } ) \leq C
+$$
+
+Therefore, the conditions for $\eta ^ { ( m ) }$ and $\alpha ^ { ( m ) }$ to satisfy the assumptions of Lemma 8 are $h > 2$ and $k \geq 1$