Momentum-Based Variance Reduction in Non-Convex SGD

Introduction

We do not assume convexity, so in general the problem of finding a true minimum of $F$ may be NP-hard. Hence, we relax the problem to finding a critical point of $F$ – that is a point such that $\nabla F(\boldsymbol{x})=0$. Also, we assume access only to stochastic gradients evaluated on arbitrary points, rather than Hessians or other information. In this setting, the standard algorithm is stochastic gradient descent (SGD). SGD produces a sequence of iterates $\boldsymbol{x}_{1},\dots,\boldsymbol{x}_{T}$ using the recursion

Recently, variance reduction has emerged as an improved technique for finding critical points in non-convex optimization problems. Stochastic variance-reduced gradient (SVRG) algorithms also produce iterates $x_{1},\dots,x_{T}$ according to the update formula (1), but now $\boldsymbol{g}_{t}$ is a variance reduced estimate of $\nabla F(\boldsymbol{x}_{t})$. Over the last few years, SVRG algorithms have improved the convergence rate to critical points of non-convex SGD from $O(1/T^{1/4})$ to $O(1/T^{3/10})$ to $O(1/T^{1/3})$ . Despite this improvement, SVRG has not seen as much success in practice in non-convex machine learning problems . Many reasons may contribute to this phenomenon, but two potential issues we address here are SVRG’s use of non-adaptive learning rates and reliance on giant batch sizes to construct variance reduced gradients through the use of low-noise gradients calculated at a “checkpoint”. In particular, for non-convex losses SVRG analyses typically involve carefully selecting learning rates, the number of samples to construct the gradient on the checkpoint points, and the frequency of update of the checkpoint points. The optimal settings balance various unknown problem parameters exactly in order to obtain improved performance, making it especially important, and especially difficult, to tune them.

In this paper, we address both of these issues. We present a new algorithm called STOchastic Recursive Momentum (Storm) that achieves variance reduction through the use of a variant of the momentum term, similar to the popular RMSProp or Adam momentum heuristics . Hence, our algorithm does not require a gigantic batch to compute checkpoint gradients – in fact, our algorithm does not require any batches at all because it never needs to compute a checkpoint gradient. Storm achieves the optimal convergence rate of $O(1/T^{1/3})$ , and it uses an adaptive learning rate schedule that will automatically adjust to the variance values of $\nabla f(\boldsymbol{x}_{t},\xi_{t})$. Overall, we consider our algorithm a significant qualitative departure from the usual paradigm for variance reduction, and we hope our analysis may provide insight into the value of momentum in non-convex optimization.

The rest of the paper is organized as follows. The next section discusses the related work on variance reduction and adaptive learning rates in non-convex SGD. Section 3 formally introduces our notation and assumptions. We present our basic update rule and its connection to SGD with momentum in Section 4, and our algorithm in Section 5. Finally, we present some empirical results in Section 6 and concludes with a discussion in Section 7.

Related Work

Variance-reduction methods were proposed independently by three groups at the same conference: Johnson and Zhang 2013, Zhang et al. 2013, Mahdavi et al. 2013, and Wang et al. 2013. The first application of variance-reduction method to non-convex SGD is due to Allen-Zhu and Hazan 2016. Using variance reduction methods, Fang et al. 2018, Zhou et al. 2018 have obtained much better convergence rates for critical points in non-convex SGD. These methods are very different from our approach because they require the calculation of gradients at checkpoints. In fact, in order to compute the variance reduced gradient estimates $\boldsymbol{g}_{t}$, the algorithm must periodically stop producing iterates $\boldsymbol{x}_{t}$ and instead generate a very large “mega-batch” of samples $\xi_{1},\dots,\xi_{N}$ which is used to compute a checkpoint gradient $\frac{1}{N}\sum_{i=1}^{N}\nabla f(\boldsymbol{v},\xi_{i})$ for an appropriate checkpoint point $\boldsymbol{v}$. Depending on the algorithm, $N$ may be as large as $O(T)$, and typically no smaller than $O(T^{2/3})$. The only exceptions we are aware of are SARAH and iSARAH . However, their guarantees do not improve over the ones of plain SGD, and they still require at least one checkpoint gradient. Independently and simultaneously with this work, have proposed a new algorithm that does improve over SGD to match our same convergence rate, although it does still require one checkpoint gradient. Interestingly, their update formula is very similar to ours, although the analysis is rather different. We are not aware of prior works for non-convex optimization with reduced variance methods that completely avoid using giant batches.

On the other hand, adaptive learning-rate schemes, that choose the values $\eta_{t}$ in some data-dependent way so as to reduce the need for tuning the values of $\eta_{t}$ manually, have been introduced by Duchi et al. 2011 and popularized by the heuristic methods like RMSProp and Adam . In the non-convex setting, adaptive learning rates can be shown to improve the convergence rate of SGD to $O(1/\sqrt{T}+(\sigma^{2}/T)^{1/4})$, where $\sigma^{2}$ is a bound on the variance of $\nabla f(\boldsymbol{x}_{t})$ . Hence, these adaptive algorithms obtain much better convergence guarantees when the problem is “easy”, and have become extremely popular in practice. In contrast, the only variance-reduced algorithm we are aware of that uses adaptive learning rates is , but their techniques apply only to convex losses.

Notation and Assumptions

In the following, we will write vectors with bold letters and we will denote the inner product between vectors $\boldsymbol{a}$ and $\boldsymbol{b}$ by $\boldsymbol{a}\cdot\boldsymbol{b}$.

Momentum and Variance Reduction

Before describing our algorithm in details, we briefly explore the connection between SGD with momentum and variance reduction.

The stochastic gradient descent with momentum algorithm is typically implemented as

where $a$ is small, i.e. $a=0.1$. In words, instead of using the current gradient $\nabla F(\boldsymbol{x}_{t})$ in the update of $\boldsymbol{x}_{t}$, we use an exponential average of the past observed gradients.

While SGD with momentum and its variants have been successfully used in many machine learning applications , it is well known that the presence of noise in the stochastic gradients can nullify the theoretical gain of the momentum term [29, e.g.]. As a result, it is unclear how and why using momentum can be better than plain SGD. Although recent works have proved that a variant of SGD with momentum improves the non-dominant terms in the convergence rate on convex stochastic least square problems , it is still unclear if the actual convergence rate can be improved.

Here, we take a different route. Instead of showing that momentum in SGD works in the same way as in the noiseless case, i.e. giving accelerated rates, we show that a variant of momentum can provably reduce the variance of the gradients. In its simplest form, the variant we propose is:

The only difference is the that we add the term $(1-a)(\nabla f(\boldsymbol{x}_{t},\xi_{t})-\nabla f(\boldsymbol{x}_{t-1},\xi_{t}))$ to the update. As in standard variance-reduced methods, we use two gradients in each step. However, we do not need to use the gradient calculated at any checkpoint points. Note that if $\boldsymbol{x}_{t}\approx\boldsymbol{x}_{t-1}$, then our update becomes approximately the momentum one. These two terms will be similar as long as the algorithm is actually converging to some point, and so we can expect the algorithm to behave exactly like the classic momentum SGD towards the end of the optimization process.

To understand why the above updates delivers a variance reduction, consider the “error in $\boldsymbol{d}_{t}$” which we denote as $\boldsymbol{\epsilon}_{t}$:

Now, notice that there is good reason to expect the second and third terms of the RHS above to be small: we can control $a(\nabla f(\boldsymbol{x}_{t},\xi_{t})-\nabla F(\boldsymbol{x}_{t}))$ simply by choosing small enough values $a$, and from smoothness we expect $(\nabla f(\boldsymbol{x}_{t},\xi_{t})-\nabla f(\boldsymbol{x}_{t-1},\xi_{t})-(\nabla F(\boldsymbol{x}_{t})-\nabla F(\boldsymbol{x}_{t-1}))$ to be of the order of $O(\|\boldsymbol{x}_{t}-\boldsymbol{x}_{t-1}\|)=O(\eta\boldsymbol{d}_{t-1})$. Therefore, by choosing small enough $\eta$ and $a$, we obtain $\|\boldsymbol{\epsilon}_{t}\|=(1-a)\|\boldsymbol{\epsilon}_{t-1}\|+Z$ where $Z$ is some small value. Thus, intuitively $\|\boldsymbol{\epsilon}_{t}\|$ will decrease until it reaches $Z/a$. This highlights a trade-off in setting $\eta$ and $a$ in order to decrease the numerator of $Z/a$ while keeping the denominator sufficiently large. Our central challenge is showing that it is possible to achieve a favorable trade-off in which $Z/a$ is very small, resulting in small error $\boldsymbol{\epsilon}_{t}$.

Storm: STOchastic Recursive Momentum

We now describe our stochastic optimization algorithm, which we call STOchastic Recursive Momentum (Storm). The pseudocode is in Algorithm 1. As described in the previous section, its basic update is of the form of (2) and (3). However, in order to achieve adaptivity to the noise in the gradients, both the stepsize and the momentum term will depend on the past gradients, à la AdaGrad .

The convergence guarantee of Storm is presented in Theorem 1 below.

Under the assumptions in Section 3, for any $b>0$, we write $k=\frac{bG^{\frac{2}{3}}}{L}$. Set $c=28L^{2}+G^{2}/(7Lk^{3})=L^{2}(28+1/(7b^{3}))$ and $w=\max\left((4Lk)^{3},2G^{2},\left(\tfrac{ck}{4L}\right)^{3}\right)=G^{2}\max\left((4b)^{3},2,(28b+\frac{1}{7b^{2}})^{3}/64\right)$. Then, Storm satisfies

where $M=\frac{8}{k}(F(\boldsymbol{x}_{1})-F^{\star})+\frac{w^{1/3}\sigma^{2}}{4L^{2}k^{2}}+\frac{k^{2}c^{2}}{2L^{2}}\ln(T+2)$.

In words, Theorem 1 guarantees that Storm will make the norm of the gradients converge to 0 at a rate of $O(\frac{\ln T}{\sqrt{T}})$ if there is no noise, and in expectation at a rate of $\frac{2\sigma^{1/3}}{T^{1/3}}$ in the stochastic case. We remark that we achieve both rates automatically, without the need to know the noise level nor the need to tune stepsizes. Note that the rate when $\sigma\neq 0$ matches the optimal rate , which was previously only obtained by SVRG-based algorithms that require a “mega-batch” .

The dependence on $G$ in this bound deserves some discussion - at first blush it appears that if $G\to 0$, the bound will go to infinity because the denominator in $M$ goes to zero. Fortunately, this is not so: the resolution is to observe that $F(\boldsymbol{x}_{1})-F^{\star}=O(G)$ and $\sigma=O(G)$, so that the numerators of $M$ actually go to zero at least as fast as the denominator. The dependence on $L$ may be similarly non-intuitive: as $L\to 0$, $M\to\infty$. In this case this is actually to be expected: if $L=0$, then there are no critical points (because the gradients are all the same!) and so we cannot actually find one. In general, $M$ should be regarded as an $O(\log(T))$ term where the constant indicates some inherent hardness level in the problem.

Finally, note that here we assumed that each $f(x,\xi)$ is $G$-Lipschitz in $x$. Prior variance reduction results (e.g. ) do not make use of this assumption. However, we we show in Appendix B that simply replacing all instances of $G$ or $G_{t}$ in the parameters of Storm with an oracle-tuned value of $\sigma$ allows us to dispense with this assumption while still avoiding all checkpoint gradients.

Also note that, as in similar work on stochastic minimization of non-convex functions, Theorem 1 only bounds the gradient of a randomly selected iterate . However, in practical implementations we expect the last iterate to perform equally well.

Our analysis formalizes the intuition developed in the previous section through a Lyapunov potential function. Our Lyapunov function is somewhat non-standard: for smooth non-convex functions, the Lyapunov function is typically of the form $\Phi_{t}=F(\boldsymbol{x}_{t})$, but we propose to use the function $\Phi_{t}=F(\boldsymbol{x}_{t})+z_{t}\|\boldsymbol{\epsilon}_{t}\|^{2}$ for a time-varying $z_{t}\propto\eta_{t-1}^{-1}$, where $\boldsymbol{\epsilon}_{t}$ is the error in the update introduced in the previous section. The use of time-varying $z_{t}$ appears to be critical for us to avoid using any checkpoints: with constant $z_{t}$ it seems that one always needs at least one checkpoint gradient. Potential functions of this form have been used to analyze momentum algorithms in order to prove asymptotic guarantees, see, e.g., Ruszczynski and Syski 1983. However, as far as we know, this use of a potential is somewhat different than most variance reduction analyses, and so may provide avenues for further development. We now proceed to the proof of Theorem 1.

First, we consider a generic SGD-style analysis. Most SGD analyses assume that the gradient estimates used by the algorithm are unbiased of $\nabla F(\boldsymbol{x}_{t})$, but unfortunately $\boldsymbol{d}_{t}$ biased. As a result, we need the following slightly different analysis. For lack of space, the proof of this Lemma and the next one are in the Appendix.

Suppose $\eta_{t}\leq\frac{1}{4L}$ for all $t$. Then

The following technical observation is key to our analysis of Storm: it provides a recurrence that enables us to bound the variance of the estimates $\boldsymbol{d}_{t}$.

With the notation in Algorithm 1, we have

Lemma 2 exhibits a somewhat involved algebraic identity, so let us try to build some intuition for what it means and how it can help us. First, multiply both sides by $\eta_{t-1}$. Technically the expectations make this a forbidden operation, but we ignore this detail for now. Next, observe that $\sum_{t=1}^{T}G_{t}^{2}$ is roughly $\Theta(T)$ (since the the variance prevents $\|g_{t}\|^{2}$ from going to zero even when $\|\nabla F(\boldsymbol{x}_{t})\|$ does). Therefore $\eta_{t}$ is roughly $O(1/t^{1/3})$, and $a_{t}$ is roughly $O(1/t^{2/3})$. Discarding all constants, and observing that $(1-a_{t})^{2}\leq(1-a_{t})$, the above Lemma is then saying that

We formalize this intuition using a Lyapunov function of the form $\Phi_{t}=F(\boldsymbol{x}_{t})+z_{t}\|\boldsymbol{\epsilon}_{t}\|^{2}$ in the proof of Theorem 1 below.

Consider the potential $\Phi_{t}=F(\boldsymbol{x}_{t})+\frac{1}{32L^{2}\eta_{t-1}}\|\boldsymbol{\epsilon}_{t}\|^{2}$. We will upper bound $\Phi_{t+1}-\Phi_{t}$ for each $t$, which will allow us to bound $\Phi_{T}$ in terms of $\Phi_{1}$ by summing over $t$. First, observe that since $w\geq(4Lk)^{3}$, we have $\eta_{t}\leq\frac{1}{4L}$. Further, since $a_{t+1}=c\eta_{t}^{2}$, we have $a_{t+1}\leq\frac{ck}{4Lw^{1/3}}\leq 1$ for all $t$. Then, we first consider $\eta_{t}^{-1}\|\boldsymbol{\epsilon}_{t+1}\|^{2}-\eta_{t-1}^{-1}\|\boldsymbol{\epsilon}_{t}\|^{2}$. Using Lemma 2, we obtain

Let us focus on the terms of this expression individually. For the first term, $A_{t}$, observe that $w\geq 2G^{2}\geq G^{2}+G_{t+1}^{2}$ to obtain:

where in the second to last inequality we used Lemma 4 in the Appendix.

Let us focus on $\frac{1}{\eta_{t}}-\frac{1}{\eta_{t-1}}$ for a minute. Using the concavity of $x^{1/3}$, we have $(x+y)^{1/3}\leq x^{1/3}+yx^{-2/3}/3$. Therefore:

where we have used that that $w\geq(4Lk)^{3}$ to have $\eta_{t}\leq\frac{1}{4L}$.

Further, since $c=28L^{2}+G^{2}/(7Lk^{3})$, we have

Thus, we obtain $B_{t}\leq-24L^{2}\eta_{t}\|\boldsymbol{\epsilon}_{t}\|^{2}$. Putting all this together yields:

Now, we are ready to analyze the potential $\Phi_{t}$. Since $\eta_{t}\leq\frac{1}{4L}$, we can use Lemma 1 to obtain

Summing over $t$ and using (4), we obtain

where the last inequality is given by the definition of $\boldsymbol{d}_{1}$ and $\eta_{0}$ in the algorithm.

Therefore, if we set $M=\frac{1}{k}\left[8(F(\boldsymbol{x}_{1})-F^{\star})+\frac{w^{1/3}\sigma^{2}}{4L^{2}k}+\frac{k^{3}c^{2}}{2L^{2}}\ln(T+2)\right]$, to get

where we have used the concavity of $x\mapsto x^{a}$ for all $a\leq 1$ to move expectations inside the exponents. Now, define $X=\sqrt{\sum_{t=1}^{T}\|\nabla F(\boldsymbol{x}_{t})\|^{2}}$. Then the above can be rewritten as:

Finally, observe that by Cauchy-Schwarz we have $\sum_{t=1}^{T}\|\nabla F(\boldsymbol{x}_{t})\|/T\leq X/\sqrt{T}$ so that

where we used $(a+b)^{1/3}\leq a^{1/3}+b^{1/3}$ in the last inequality. ∎

Empirical Validation

In order to confirm that our advances do indeed yield an algorithm that performs well and requires little tuning, we implemented Storm in TensorFlow and tested its performance on the CIFAR-10 image recognition benchmark using a ResNet model , as implemented by the Tensor2Tensor package https://github.com/google-research/google-research/tree/master/storm_optimizer. We compare Storm to AdaGrad and Adam, which are both very popular and successful optimization algorithms. The learning rates for AdaGrad and Adam were swept over a logarithmically spaced grid. For Storm, we set $w=k=0.1$ as a default We picked these defaults by tuning over a logarithmic grid on the much-simpler MNIST dataset . $w$ and $k$ were not tuned on CIFAR10. and swept $c$ over a logarithmically spaced grid, so that all algorithms involved only one parameter to tune. No regularization was employed. We record train loss (cross-entropy), and accuracy on both the train and test sets (see Figure 1).

These results show that, while Storm is only marginally better than AdaGrad on test accuracy, on both training loss and accuracy Storm appears to be somewhat faster in terms of number of iterations. We note that the convergence proof we provide actually only applies to the training loss (since we are making multiple passes over the dataset). We leave for the future whether appropriate regularization can trade-off Storm’s better training loss performance to obtain better test performance.

Conclusion

We have introduced a new variance-reduction-based algorithm, Storm, that finds critical points in stochastic, smooth, non-convex problems. Our algorithm improves upon prior algorithms by virtue of removing the need for checkpoint gradients, and incorporating adaptive learning rates. These improvements mean that Storm is substantially easier to tune: it does not require choosing the size of the checkpoints, nor how often to compute the checkpoints (because there are no checkpoints), and by using adaptive learning rates the algorithm enjoys the same robustness to learning rate tuning as popular algorithms like AdaGrad or Adam. Storm obtains the optimal convergence guarantee, adapting to the level of noise in the problem without knowledge of this parameter. We verified that on CIFAR-10 with a ResNet architecture, Storm indeed seems to be optimizing the objective in fewer iterations than baseline algorithms.

Additionally, we point out that Storm’s update formula is strikingly similar to the standard SGD with momentum heuristic employed in practice. To our knowledge, no theoretical result actually establishes an advantage of adding momentum to SGD in stochastic problems, creating an intriguing mystery. While our algorithm is not precisely the same as the SGD with momentum, we feel that it provides strong intuitive evidence that momentum is performing some kind of variance reduction. We therefore hope that some of the analysis techniques used in this paper may provide a path towards explaining the advantages of momentum.

This material is based upon work supported by the National Science Foundation under grant no. 1925930 “Collaborative Research: TRIPODS Institute for Optimization and Learning”.

References

Appendix A Extra Lemmas

In this section we (re)state and prove some Lemmas.

First, we provide the proof of Lemma 1, restated below for convenience. See 1

Using the smoothness of $F$ and the definition of $\boldsymbol{x}_{t+1}$ from the algorithm, we have

where in the second inequality we used Young’s inequality, the third one uses $\|\boldsymbol{x}+\boldsymbol{y}\|^{2}\leq 2\|\boldsymbol{x}\|^{2}+2\|\boldsymbol{y}\|^{2}$, and the last one uses $\eta_{t}\leq 1/4L$. ∎

This next Lemma is a technical observation that is important for the proof of Lemma 2.

From inspection of the update formula, the hypothesis implies that $\boldsymbol{\epsilon}_{t-1}=\boldsymbol{d}_{t-1}-\nabla F(\boldsymbol{x}_{t-1})$ and $\boldsymbol{x}_{t}$ are both independent of $\xi_{t}$. Then, by first taking expectation with respect to $\xi_{t}$ and then with respect to $\xi_{1},\dots,\xi_{t-1}$, we obtain

Analogously, for the second equality we have

The following Lemma is a standard consequence of convexity.

Let $a_{0}>0$ and $a_{1},\dots,a_{T}\geq 0$. Then

By the concavity of the log function, we have

Summing over $t=1,\dots,T$ both sides of the inequality, we have the stated bound. ∎

In this section we present the deferred proof of Lemma 2, restating the result below for reference See 2

By definition of $\boldsymbol{\epsilon}_{t}$ and the notation in Algorithm 1, we have $\boldsymbol{\epsilon}_{t}=\boldsymbol{d}_{t}-\nabla F(\boldsymbol{x}_{t})=\nabla f(\boldsymbol{x}_{t},\xi_{t})+(1-a_{t})(\boldsymbol{d}_{t-1}-\nabla f(\boldsymbol{x}_{t-1},\xi_{t}))-\nabla F(\boldsymbol{x}_{t})$. Hence, we can write

where in the first inequality we used Lemma 3 (See Appendix A) and $\|\boldsymbol{x}+\boldsymbol{y}\|^{2}\leq 2\|\boldsymbol{x}\|^{2}+2\|\boldsymbol{y}\|^{2}$, in the second inequality we used (5) and (6), in the third one the Lipschitzness and smoothness of the functions $f$, and in the last inequality we used again $\|\boldsymbol{x}+\boldsymbol{y}\|^{2}\leq 2\|\boldsymbol{x}\|^{2}+\|\boldsymbol{y}\|^{2}$. ∎

Appendix B Non-adaptive Bound Without Lipschitz Assumption

In our analysis of Storm in Theorem 1 we assume that the losses are $G$-Lipschitz for some known constant $G$ with probability 1. Often this kind of Lipschitz assumption is avoided in other variance-reduction analyses . These works also require oracle knowlede of the parameter $\sigma$. It turns out that our use of this assumption is actually only necessary in order to facilitate our adaptive analysis - in fact even for ordinary (non-variance-reduced) gradient descent methods the Lipschitz assumption seems to be a common thread in adaptive analyses . If we are given access to the true value of $\sigma$, then we can choose a deterministic learning rate schedule in order to avoid requiring a Lipschitz bound. All that needs be done is replace all instances of $G$ or $G_{t}$ in Storm with the oracle-tuned value $\sigma$, which we outline in Algorithm 2 below.

The convergence guarantee of Algorithm 2 is presented in Theorem 2 below, which is nearly identical to Theorem 1 but losses adaptivity to $\sigma$ in exchange for removing the $G$-Lipschitz requirement.

Under the assumptions in Section 3, for any $b>0$, we write $k=\frac{b\sigma^{\frac{2}{3}}}{L}$. Set $c=28L^{2}+\sigma^{2}/(7Lk^{3})=L^{2}(28+1/(7b^{3}))$ and $w=\max\left((4Lk)^{3},2\sigma^{2},\left(\tfrac{ck}{4L}\right)^{3}\right)=\sigma^{2}\max\left((4b)^{3},2,(28b+\frac{1}{7b^{2}})^{3}/64\right)$. Then, Algorithm 2 satisfies

where $M=8(F(\boldsymbol{x}_{1})-F^{\star})+\frac{w^{1/3}\sigma^{2}}{4L^{2}k}+\frac{k^{3}c^{2}}{2L^{2}}\ln(T+2)$.

In order to prove this Theorem, we need a non-adaptive analog of Lemma 2:

With the notation in Algorithm 2, we have

This proof is also nearly identical to the analogous adaptive result of Theorem 1.

Again, we consider the potential $\Phi_{t}=F(\boldsymbol{x}_{t})+\frac{1}{32L^{2}\eta_{t-1}}\|\boldsymbol{\epsilon}_{t}\|^{2}$ and upper bound $\Phi_{t+1}-\Phi_{t}$ for each $t$.

Since $w\geq(4Lk)^{3}$, we have $\eta_{t}\leq\frac{1}{4L}$. Further, since $a_{t+1}=c\eta_{t}^{2}$, we have $a_{t+1}\leq\frac{ck}{4Lw^{1/3}}\leq 1$ for all $t$. Then, we first consider $\eta_{t}^{-1}\|\boldsymbol{\epsilon}_{t+1}\|^{2}-\eta_{t-1}^{-1}\|\boldsymbol{\epsilon}_{t}\|^{2}$. Using Lemma 5, we obtain

Let us focus on the terms of this expression individually. For the first term, $A_{t}$, observe that $w\geq 2\sigma^{2}$ to obtain:

Let us focus on $\frac{1}{\eta_{t}}-\frac{1}{\eta_{t-1}}$ for a minute. Using the concavity of $x^{1/3}$, we have $(x+y)^{1/3}\leq x^{1/3}+yx^{-2/3}/3$. Therefore:

where we have used that that $w\geq(4Lk)^{3}$ to have $\eta_{t}\leq\frac{1}{4L}$.

Further, since $c=28L^{2}+\sigma^{2}/(7Lk^{3})$, we have

Thus, we obtain $B_{t}\leq-24L^{2}\eta_{t}\|\boldsymbol{\epsilon}_{t}\|^{2}$. Putting all this together yields:

Now, we analyze the potential $\Phi_{t}$. This analysis is completely identical to that of Theorem 1, and is only reproduced here for convenience. Since $\eta_{t}\leq\frac{1}{4L}$, we can use Lemma 1 to obtain

Summing over $t$ and using (7), we obtain

where the last inequality is given by the definition of $\boldsymbol{d}_{1}$ and $\eta_{0}$ in the algorithm.

At this point the rest of the proof could proceed in an identical manner to that of Theorem 1. However, since $\eta_{t}$ is now idependent of $\nabla F(x_{t})$ by virtue of being deterministic, we can simplify the remainder of the proof somewhat by avoiding the use of Cauchy-Schwarz inequality.

where we have used the definition $M=8(F(\boldsymbol{x}_{1})-F^{\star})+\frac{w^{1/3}\sigma^{2}}{4L^{2}k}+\frac{k^{3}c^{2}}{2L^{2}}\ln(T+2)$ and the identity $(a+b)^{1/3}\leq a^{1/3}+b^{1/3}$ ∎