Quasi-hyperbolic momentum and Adam for deep learning

Introduction

Stochastic gradient descent (SGD) serves as the optimizer of choice for many recent advances in deep learning across domains (Krizhevsky et al. 2012; He et al. 2016a; Gehring et al. 2017). SGD for deep learning is typically augmented with either the “heavy ball” momentum technique of Polyak 1964 or the accelerated gradient of Nesterov 1983. In the deterministic setting, these methods provably yield faster convergence in fairly general settings. In the stochastic setting, these methods lose many theoretical advantages. However, due to its implicit gradient averaging, momentum can confer the benefit of variance reduction, applying less noisy parameter updates than plain SGD. Recent work has explicitly shown the use of momentum as a variance reducer (Roux et al. 2018).

Starting with gradient variance reduction as an informal and speculative motivation, we introduce the quasi-hyperbolic momentum (QHM) optimization algorithm in Section 3. Put as simply as possible, QHM’s update rule is a weighted average of momentum’s and plain SGD’s update rule. We later propose a similar variant of Adam (QHAdam) in Section 5.

QHM is simple yet expressive. In Section 4, we connect QHM with plain SGD, momentum, Nesterov’s accelerated gradient, PID control algorithms (Recht 2018; An et al. 2018), synthesized Nesterov variants (Lessard et al. 2016), noise-robust momentum (Cyrus et al. 2018), Triple Momentum (Scoy et al. 2018), and least-squares acceleration of SGD (Kidambi et al. 2018). Such connections yield reciprocal benefits – these algorithms aid in analyzing QHM, and conversely QHM recovers many of these algorithms in a more efficient and conceptually simpler manner. We then characterize the set of optimization algorithms that QHM recovers.

In Section 6, we empirically demonstrate that QHM and QHAdam provide superior optimization in a variety of deep learning settings. We provide both comprehensive parameter sweep analyses on smaller models and case studies on large real-world models. We demonstrate improvements on strong (sometimes state-of-the-art) models simply by swapping out the vanilla algorithms with the QH counterpart. Notably, taking the WMT16 EN-DE translation model of Ott et al. 2018, we achieve a 40% improvement in stability, along with a new state-of-the-art result of 29.45 BLEU. We then offer some practical tips for QHM and QHAdam.

We provide errata for Kingma & Ba 2015, Recht 2018, and Kidambi et al. 2018. We also offer evidence that momentum often yields negligible improvement over plain SGD.

We emphasize QHM and QHAdam’s efficiency and conceptual simplicity. QHM has no extra overhead vs. Nesterov’s accelerated gradient, and QHAdam has very little overhead vs. Adam. Also, both algorithms are easily understood as an interpolation between two other well-known algorithms, so they are accessible to practitioners and can be tuned starting with existing practical intuitions. We believe that this contributes strongly to the algorithms’ practical promise.

Preliminaries

We begin with notation and a brief review of stochastic gradient descent (SGD) and momentum.

We consider optimization algorithms that perform a sequence of steps (indexed by $t$), updating $\theta$ at each step towards minimizing $L(\theta)$. For brevity, we write algorithms as “update rules”, which describe the algorithm’s behavior during a single step $t$, rather than as full pseudocode. Update rules take this basic form (optionally with one or more auxiliary steps):

where $g$ is commonly called the “momentum buffer”. Note that $\beta=0$ recovers plain SGD.

The exponential discount factor $\beta$ controls how slowly the momentum buffer is updated. In the stochastic setting, $\beta$ also controls the variance of a normalized momentum buffer. A common rule of thumb for momentum is $\beta=0.9$ (Ruder 2016). Additionally, Kingma & Ba 2015 recommends $\beta_{1}=0.9$ for Adam, and $\beta_{1}=0.9$ is the default for Adam in both the PyTorch and TensorFlow frameworks (Paszke et al. 2017; Abadi et al. 2015).

In contrast to common formulations of momentum (Polyak 1964; Sutskever et al. 2013), we normalize, or “dampen”, the momentum buffer $g$ by $(1-\beta)$ in Eq. 1. This serves both to remove dependence of the update step magnitude on $\beta$, and to allow the interpretation of $g$ as a weighted average of past gradients (and thus a gradient estimator). Of course, this also shrinks the updates by a factor of $1-\beta$ vs. common formulations; this is easily reversible with a corresponding increase to $\alpha$.

Algorithm: Quasi-hyperbolic momentum (QHM)

In this section, we propose and discuss the quasi-hyperbolic momentum (QHM) algorithm.

QHM introduces the immediate discount factor $\nu$, encapsulating plain SGD ($\nu=0$) and momentum ($\nu=1$). A self-evident interpretation of QHM is as a $\nu$-weighted average of the momentum update step and the plain SGD update step.

Comparing Eq. 2 and Eq. 4, QHM may seem at first glance identical to momentum with discount factor $\nu\beta$. Section A.8 analytically demonstrates that this is not the case. We note that the expressive power of QHM intuitively comes from decoupling the momentum buffer’s discount factor ($\beta$) from the current gradient’s contribution to the update rule ($1-\nu\beta$). In contrast, momentum tightly couples the discount factor ($\beta$) and the current gradient’s contribution ($1-\beta$).

QHM is originally motivated by an informal and speculative variance reduction analysis; for brevity, we provide the full details in Appendix A. The appendix also sheds some light on the nomenclature, adopted from the hyperbolic discounting work pioneered by Chung & Hernstein 1961, Phelps & Pollak 1968, and Laibson 1997 in consumer choice. We caution that “quasi-hyperbolic” does not directly relate to the geometry of hyperbolas. In short, the square bracket term in Eq. 4 can be viewed as a gradient estimator (modulo initialization bias). When $\nu=1$, this is simply the momentum buffer $g_{t+1}$. Increasing $\beta$ decreases the variance of the momentum buffer, but potentially at the cost of making it unusably “stale” (biased). QHM allows for the mitigation of this staleness by upweighting the current, unbiased gradient (i.e. setting $\nu<1$).

QHM, like momentum, requires 1 auxiliary buffer of memory. It also requires 1 in-place scalar-vector multiplication and 3 scaled vector additions per update step.

Connections to other algorithms

We now present numerous connections between QHM and other optimization algorithms. The common theme is that QHM recovers almost all of these algorithms, and thus is a highly interpretable and more efficient implementation of these algorithms. The first few subsections present these connections, Appendix C presents a deeper theoretical treatment of Section 4.2 through Section 4.4, which are largely narrative. Table 1 summarizes these connections, and Section 4.5 provides discussion.

Nesterov 1983’s accelerated gradient (NAG) can be viewed as a closely related cousin of momentum. In fact, replacing the $g_{t+1}$ term in Eq. 2 with $[(1-\beta)\cdot\nabla\hat{L}_{t}(\theta_{t})+\beta\cdot g_{t+1}]$ yields NAG.

It follows from Eq. 4 that QHM recovers NAG with $\nu=\beta$. This sheds light on the somewhat unintuitive NAG algorithm, providing a natural interpretation of NAG’s update rule as a $\beta$-weighted average between momentum and plain SGD.

NAG’s compute/memory cost is equivalent to that of QHM.

2 PID control

Recht 2018 draws a strong connection between gradient-based optimization and PID control. We regurgitate the excellent exposition (with minor modifications) in Appendix B.

We fully relate QHM and PID in Section C.3. To summarize, PID is a superfamily of QHM. Viewing $\beta$ as a constant, QHM imposes a restriction on the ratio between $k_{P}$ and $k_{D}$. Viewing $\beta$ as a free variable, however, QHM can recover nearly all PID coefficients.

Recht 2018 provides a transformation of variables that reduces the memory cost to 2 auxiliary buffers, and the compute cost to 1 in-place scalar-vector multiplication and 4 scaled vector additions per update step. This is still costlier than QHM.

In Appendix E, we briefly discuss another PID setting by An et al. 2018 and relate the resulting optimization algorithm to QHM. In short, the setting is degenerate as the P, I, and D terms are linearly dependent. Thus, QHM can recover the resulting PID control optimizer.

3 Synthesized Nesterov Variants (SNV)

Section 6 of Lessard et al. 2016 describes a “synthesized Nesterov variant” algorithm, which we call “SNV” for convenience. This algorithm is used to analyze and improve optimizer robustness under “relative deterministic noise” (i.e. multiplicative noise of the gradient).

We fully relate QHM and SNV in Section C.4. To summarize, QHM and SNV recover each other. By extension, QHM recovers the Robust Momentum method, which is a specific parameterization of SNV (Cyrus et al. 2018). Moreover, since Robust Momentum recovers the Triple Momentum of Scoy et al. 2018, QHM also recovers Triple Momentum.

SNV is costlier than QHM, requiring 2 auxiliary buffers and 5 scaled vector additions.

4 AccSGD

Jain et al. 2017 and Kidambi et al. 2018 point out various failures of momentum and NAG in the setting of stochastic least squares optimization. This motivates their proposal of the AccSGD algorithm, which yields faster convergence over momentum and NAG in certain least-squares regression settings. Here, we discuss the formulation of Kidambi et al. 2018.

AccSGD, parameterized by $\delta>0$, $\kappa>1$, $\xi\leq\sqrt{\kappa}$, and ${\epsilon}<1$, uses the update rule:

We fully relate QHM and AccSGD in Section C.5. To summarize, QHM recovers AccSGD. In the reverse direction, AccSGD does not recover QHM; specifically, we disprove the claim in Kidambi et al. 2018 that AccSGD recovers NAG. Since QHM recovers NAG, AccSGD cannot fully recover QHM.

AccSGD, like QHM, requires 1 auxiliary buffer. Computationally, AccSGD is costlier, requiring 2 in-place scalar-vector multiplications and 4 scaled vector additions per update step.

5 Discussion

We note that various convergence results follow simply via these connections. In the deterministic (full-batch) case, since QHM recovers Triple Momentum, QHM also recovers the global linear convergence rate of $1-1/\sqrt{\kappa}$ for strongly convex, smooth loss functions. Here, $\kappa$ is the ratio between the Lipschitz constant of $\nabla L(\cdot)$ and the strong convexity parameter of $L(\cdot)$. For first-order methods, this is the fastest known global convergence rate for such functions. In the stochastic (minibatch) case, QHM’s recovery of AccSGD gives QHM the same convergence results as in Kidambi et al. 2018’s least-squares regression setting, of ${\mathcal{O}}(\sqrt{\kappa}\cdot\log{\kappa}\cdot\log{\frac{1}{{\epsilon}}})$ iterations for ${\epsilon}$-approximation of the minimal loss.

These connections demonstrate that many two-state optimization algorithms are functionally similar or equivalent to each other. However, they are often implemented inefficiently and their parameterizations can be inaccessible to practitioners. QHM yields a highly accessible and efficient version of these algorithms.

In Appendix D, we characterize the set of two-state optimization algorithms recoverable by QHM. Our hope here is to provide future work with a routine conversion to QHM so that they may leverage the accessibility and efficiency benefits, as well as the many connections to other algorithms.

Going beyond a single momentum buffer, it is possible to recover many-state algorithms by linearly combining many momentum buffers (with different discount factors) in the update rule. However, we found in preliminary experiments that using multiple momentum buffers yields negligible value over using a single slow-decaying momentum buffer and setting an appropriate immediate discount – that is, using QHM with high $\beta$ and appropriate $\nu$.

We note that the Aggregated Momentum (AggMo) algorithm (Lucas et al. 2018) precisely performs this linear combination of multiple momentum buffers. While AggMo takes a simple average of the buffers, an extended variant of AggMo allows for other linear combinations. This extended AggMo can be viewed as a many-state generalization of two-state algorithms (including QHM), recovering them when two buffers are used. Appendix H provides a supplemental discussion and empirical comparison of QHM and AggMo, corroborating our preliminary experiments’ findings.

Algorithm: QHAdam

The Adam optimizer (Kingma & Ba 2015) has enabled many compelling results in deep learning (Xu et al. 2015; Vaswani et al. 2017; Yu et al. 2018). We propose to replace both of Adam’s moment estimators with quasi-hyperbolic terms, and we name the resulting algorithm QHAdam.

QHAdam incurs four extra scaled vector additions over Adam.

We leave formal convergence analysis to future work. However, a couple of informal points are worth mentioning. Firstly, $\nu_{1}$ and $\beta_{1}$ can be reasoned about in a similar manner to QHM’s $\nu$ and $\beta$. Secondly, when replacing Adam with QHAdam, setting $\nu_{2}=1$ and $\beta_{2}$ unchanged is usually reasonable if the original Adam training is stable. Thirdly, when Adam training is not stable, it is possible that setting $\nu_{2}<1$ can improve stability by imposing a tighter step size bound – Appendix F elaborates, disproving the step size bound claimed in Kingma & Ba 2015.

Experiments

We perform two categories of experiments: parameter sweeps and case studies. For brevity, all experimental settings are summarized in Table 2 and comprehensively detailed in Appendix I.

With parameter sweeps, we aim to comprehensively study the various parameterizations of the QH algorithms using relatively small models. We train for 90 epochs with size-64 minibatches. For QHM, we initialize $\alpha=1$ and decay it 10-fold every 30 epochs. The sweep grid for QHM (encapsulating various parameterizations of plain SGD, momentum, and NAG) is:

For QHAdam, we fix $\alpha=10^{-3}$, ${\epsilon}=10^{-8}$, $\nu_{2}=1$, and $\beta_{2}=0.999$, and sweep over $\nu_{1}$ and $\beta_{1}$.

Motivated by the popular momentum/NAG “default” of $\beta=0.9$, we select a QH “default” of $\nu=0.7$ and $\beta=0.999$ based on preliminary experimentation on the MNIST dataset (LeCun 1998) along with the intuitions from Appendix A. In the following figures, we show these defaults along with the globally optimal parameterizations.

Fig. 1 presents selected results of these sweep experiments (full results in Appendix J). Perhaps the most immediate observation is that the QH algorithms improve both training and validation metrics. Even the hardcoded default $\nu=0.7$ and $\beta=0.999$ handily outperforms the optimal parameterization of NAG or Adam in all settings. In some settings, there remains a large gap between the QH and vanilla algorithms at the end of training. In other settings, the gap shrinks to smaller levels. However, even for these latter settings, the QH algorithm converges much faster, suggesting that a more aggressive learning rate schedule can significantly reduce training time.

We note that in most of these experiments, there is little difference between the performance of plain SGD and NAG (particularly when compared to QHM). Although not shown in the figures, there is also little difference between plain SGD and momentum. This indicates that the benefit of momentum and NAG (in the common, unnormalized formulations) comes in large part from the increase in effective step size. We thus suspect that much of the folk wisdom about momentum’s benefits for SGD should instead be folk wisdom about using sensible learning rates. In contrast, QHM provides significant benefits without changing the effective step size.

2 Case studies

With case studies, we apply the QH algorithms to diverse settings, with (currently or recently) state-of-the-art models. Our case studies cover image recognition, language modeling, reinforcement learning, and neural machine translation. Each case study features a baseline setting and a QH setting, which are identical modulo the optimizer used. Results are presented in Fig. 2 and Table 3.

We train a ResNet152 model (He et al. 2016a) on the ILSVRC2012 dataset (Russakovsky et al. 2015). The baseline setting is nearly identical to the size-256 minibatch baseline in Goyal et al. 2017, using NAG with $\beta=0.9$ and a decaying learning rate schedule. The QH setting swaps out NAG for QHM, with $\nu=0.7$ and $\beta=0.999$. Here, we did not sweep over alternate parameterizations.

Running 3 seeds, QHM plainly trains much faster than NAG, and QHM converges to a marginally superior validation error as well. We also train the model using plain SGD, again finding that plain SGD performs nearly as well as NAG throughout training. Although not shown, plain SGD in fact performs better than momentum. The validation loss curves for plain SGD, momentum, and NAG are indistinguishable throughout training, suggesting that momentum/NAG is not needed in Goyal et al. 2017.

Deep learning for NLP often features “spiky” gradient distributions (e.g. encountering rare words). We train a FConv language model (Dauphin et al. 2016) on the WikiText-103 dataset (Merity et al. 2016). The baseline setting precisely follows the original paper, using NAG with $\beta=0.99$. The QH setting swaps out NAG for QHM, with $\nu=0.98$ and $\beta=0.998$. 7 We suspect that high $\beta$ improves stability in the presense of spiky gradients, and QHM’s $\nu$ allows the use of high $\beta$.

Running 10 seeds, QHM outperforms the NAG baseline on validation perplexity by half a point.

Reinforcement learning presents a challenging task for gradient-based optimization, since the objective $L$ is not stationary. QH algorithms provide a natural way of upweighting the most recent gradient. Here, we apply the TD3 algorithm (Fujimoto et al. 2018) to various MuJoCo environments (Todorov et al. 2012). The baseline precisely follows Fujimoto et al. 2018’s setup, which uses Adam with $\beta_{1}=0.9$ and $\beta_{2}=0.999$. The QH setting swaps out Adam for QHAdam, with $\nu_{1}=0.9$ and other parameters identical. Here, we tried higher values of $\beta_{1}$. Significantly increasing $\beta_{1}$ was not fruitful for either algorithm.

Running 10 seeds, QHAdam yields improvements in average reward on four environments out of seven tested, and virtually ties on another.

Many state-of-the-art neural machine translation (NMT) models are fragile to train. As in language modeling, the gradient distribution is often ‘‘spiky’’; thus, Adam training often fails to converge due to a very small number of large parameter updates. Refer to Appendix F for a more detailed theoretical treatment. Here, we empirically demonstrate that QHAdam improves both performance and robustness by using $\nu_{2}$ to control the maximum per-step update. We train a large transformer model (Vaswani et al. 2017) on the WMT16 English-German dataset. The baseline setting precisely follows the state-of-the-art setup of Ott et al. 2018, using $\beta_{1}=0.9$ and $\beta_{2}=0.98$ for Adam. The QH setting swaps out Adam for QHAdam, with $\nu_{1}=0.8$, $\beta_{1}=0.95$, $\nu_{2}=0.7$, and $\beta_{2}=0.98$. Here, we tried two other parameterizations (higher $\beta_{1}$) with marginal success.

Running 10 seeds, the Adam baseline explodes on 4 seeds. QHAdam is more robust, converging for all seeds. Ultimately, QHAdam yields a new state-of-the-art-result of 29.45 BLEU. Thus, we improve both the stability and performance of the state-of-the-art with a simple optimizer swap.

Discussion

We offer some practical suggestions for deep learning practitioners, particularly those who default to momentum, NAG, or Adam with $\beta=0.9$ as a rule of thumb:

Consider using QHM or QHAdam, instead of momentum, NAG, or Adam.

While QHM parameters should be tuned when feasible, a decent rule of thumb is to set $\nu=0.7$ and $\beta=0.999$. QHAdam parameter selection is somewhat more situational, although as discussed in Section 5, $\nu_{2}=1$ and $\beta_{2}$ unchanged is usually reasonable when replacing a stable Adam optimizer with QHAdam.

Be mindful of learning rate differences between (unnormalized) momentum/NAG and QHM. Convert learning rates from the former to the latter via multiplication by $(1-\beta)^{-1}$. For example, momentum/NAG with $\alpha=0.1$ and $\beta=0.9$ should be replaced by QHM with $\alpha=1$. This conversion is unnecessary for Adam, as it already normalizes all buffers.

2 Future work

This paper has only scratched the surface when it comes to empirical evaluation of QHM and QHAdam. Future work could apply the algorithms to other well-studied tasks and architectures, both to assess the extent of their performance gains in diverse domains, and to further develop insights into hyperparameter choice.

Effective hyperparameter autotuning methods can improve the practicality of any optimization algorithm. Thus, a useful direction for future work is to create an effective $\nu,\beta$ adapter, possibly based on techniques such as YellowFin (Zhang et al. 2017) or via continuous-time optimal control analysis, as in Li et al. 2017. Moreover, learning rate adaptation techniques such as Hypergradient Descent (Baydin et al. 2018) can be applied to both QHM and QHAdam.

Future work could develop convergence results for QHAdam. Convergence results for QHM in a reasonably general stochastic setting would also be appealing, although we are not aware of compelling analogous results for momentum or NAG.

Finally, momentum has been studied in the distributed, asynchronous setting, with some noting that the delays in asynchronous SGD are, in some sense, akin to adding momentum (Mitliagkas et al. 2016). As a result, the optimal momentum constant $\beta$ shrinks as more asynchronous workers are added to optimization. It would be interesting to extend these results to QHM, especially to disentagle the implicit effects of asynchrony on $\nu$ and $\beta$.

3 Conclusion

QHM and QHAdam are computationally cheap, intuitive to interpret, and simple to implement. They can serve as excellent replacements for momentum/NAG and Adam in a variety of settings. In particular, they enable the use of high exponential discount factors (i.e. $\beta$) through the use of immediate discounting (i.e. $\nu$). QHM recovers numerous other algorithms in an efficient and accessible manner. Parameter sweep experiments and case studies demonstrate that the QH algorithms can handily outpace their vanilla counterparts. We hope that practitioners and researchers will find these algorithms both practically useful and interesting as a subject of further study.

We thank Aaron Defazio, Nicolas Loizou, Yann Olivier, Mark Tygert, and anonymous reviewers and commenters for insightful discussions and valuable suggestions.

References

Appendices

This paper’s appendices are ordered as follows:

Appendix A presents a view of momentum and QHM as discounted sums, and provides the original motivation for the development of QHM.

Appendix B regurgitates Recht 2018’s excellent exposition of gradient-based optimization as PID control, with minor modifications.

Appendix C presents analyses of various other algorithms, towards connecting them to QHM.

Appendix D describes the set of all two-state optimization algorithms recovered by QHM.

Appendix E briefly discusses a PID control optimization setting by An et al. 2018.

Appendix F derives a tight upper bound on the updates of Adam and QHAdam (consequently disproving the bound in Kingma & Ba 2015), then discusses the implications on training stability.

Appendix G provides miscellaneous derivations that do not cleanly fit in other sections.

Appendix H provides discussion and an empirical comparison of QHM and AggMo (Lucas et al. 2018).

Appendix I comprehensively describes the setup of this paper’s parameter sweep and case study experiments.

Appendix J comprehensively presents the results of this paper’s parameter sweep experiments.

Appendix A Discounted sum estimators (original variance reduction motivation for QHM)

We now provide an interpretation of the momentum buffer as a discounted sum estimator, seeking to motivate the QHM algorithm from a variance reduction perspective.

When $\sum_{i=0}^{t}\delta(i)=1$ for all $t\geq 0$, we call this a discounted sum average. When $\sum_{i=0}^{\infty}\delta(i)=1$, we call this a discounted sum average (modulo initialization bias).

A.2 Exponential discounting and EWMA

For $\beta\in(-1,1)$, we define the exponential discount function $\delta_{\text{EXP},\beta}$ as:

and the exponentially weighted moving average $\operatorname{EWMA}_{\beta}(x_{0\dots t})$ as:

The EWMA is a discounted sum average (modulo initialization bias), so it can be viewed as an estimator of the expectation of a random variable $x$ if $x_{0\dots t}\sim x$. Note that the momentum buffer $g_{t}$ from Eq. 1 is precisely an EWMA – specifically, $g_{t}=\operatorname{EWMA}_{\beta}(\nabla\hat{L}_{0\dots t}(\theta_{0\dots t}))$.

It is well known that the exponential discount function is the only time-consistent (commonly “memoryless”), discount function – i.e. for any $i,\tau\geq 0$, the ratio $d(i+\tau)/d(i)$ depends only on $\tau$. This is precisely why the EWMA can be tracked with no auxiliary memory – for example, as in momentum’s update rule.

A.3 EWMA as variance reduction

We now provide the following fact about the covariance of the EWMA when $x_{0\dots t}$ are random variables.

Assume that $x_{0\dots t}$ are independent random vectors, each with the covariance matrix $\Sigma$. Then:

This means that arbitrary variance reduction of the EWMA is possible by increasing $\beta$. For example, $\beta=0.9$ implies that the covariance is reduced to $\frac{1}{19}\cdot\Sigma$, and $\beta=0.99$ implies that the covariance is reduced to $\frac{1}{199}\cdot\Sigma$.

This provides an intuitive explanation of momentum as a variance reduction technique. Assuming that the momentum buffer is normalized (and thus interpretable as an estimator of the gradient), applying momentum will reduce the variance of the update steps, with higher $\beta$ leading to more variance reduction.

However, the flip side is that higher $\beta$ induces more bias (informally, “staleness”) in the momentum buffer with respect to the true gradient, as the momentum buffer becomes extremely slow to update. Thus, the question arises: can we achieve variance reduction while guaranteeing that recent gradients contribute significantly to the update step? For this, we must introduce time-inconsistency.

A.4 (Pure) hyperbolic discounting and HWMA

Hyperbolic discounting, first proposed by Chung & Hernstein 1961, is the classical time-inconsistent discount function in consumer choice. It is commonly used to model individual behaviors such as impatience. We consider its use in the setting of stochastic optimization (in place of the EWMA buffer of momentum).

For constants $c,k>0$, we define the hyperbolic discount function as: Slightly adapted from the original formulation.

and the hyperbolic weighted moving average $\operatorname{HWMA}_{c,k}(x_{0\dots t})$ as:

Note that the hyperbolic discount function is time-inconsistent, since:

Unlike the EWMA, the HWMA is not a discounted sum average – in fact, $\sum_{i=0}^{\infty}\delta_{\text{H},c,k}(i)=\infty$ holds regardless of choice of $c$ or $k$. Thus, to use an HWMA of gradients in an optimization algorithm, $c$ (or the learning rate $\alpha$) must be decayed at a logarithmic rate. More concerning, however, is the computational inefficiency of the HWMA; specifically, the sum must be recomputed from scratch at each iteration from all past gradients. This is unacceptable for use in most practical applications.

However, in preliminary stochastic optimization experiments, we did observe a marked benefit of HWMA over EWMA (i.e. momentum), limiting the number of past gradients used for tractability. This indicates that time-inconsistency might be a useful property to have in a stochastic optimizer.

A.5 Quasi-hyperbolic discounting and QHWMA

Quasi-hyperbolic discounting, proposed by Phelps & Pollak 1968 and popularized in consumer choice by Laibson 1997, seeks to qualitatively approximate the time-inconsistency of hyperbolic discounting by applying a discontinuous “upweighting” of the current step. Its tractability has resulted in much wider adoption in consumer choice vs. pure hyperbolic discounting, and we find that it is also more suited for use in practical optimization.

and the quasi-hyperbolic weighted moving average $\operatorname{QHWMA}_{\nu,\beta}(x_{0\dots t})$ as:

The QHWMA, like the EWMA, is a discounted sum average (modulo initialization bias), so it can also be viewed as an estimator under the same assumptions.

When $\nu=1$, the QHWMA is precisely the EWMA (with identical $\beta$), and the quasi-hyperbolic discount function is precisely the exponential discount function (and thus time-consistent). When $\nu\neq 1$, the quasi-hyperbolic discount function, like the hyperbolic discount function, is time-inconsistent since:

depends on both $i$ and $\tau$; specifically, $i=0$ yields a different ratio than $i>0$.

Note from Eq. 5 that the QHWMA is a $\nu$-weighted average of the EWMA (with identical $\beta$) and $x_{0}$. This means that the QHWMA can be easily computed online by simply keeping track of the EWMA, thus requiring no additional memory.

A.6 Variance of QHWMA

We now characterize the variance of a QHWMA using this fact:

Assume that $x_{0\dots t}$ are independent random vectors, each with the covariance matrix $\Sigma$. Then:

$\rho$ is essentially a scaling factor for the covariance of the QHWMA. It can be verified that $\rho$ decreases (thus inducing variance reduction) with both increasing $\beta$ and increasing $\nu$.

A.7 Motivating QHM

This leads to our motivation for QHM, which simply replaces the EWMA momentum buffer with a QHWMA. Starting with any momentum parameterization ($\nu=1$ and $\beta\in(0,1)$), $\beta$ can be increased towards variance reduction (i.e. lowering $\rho$). Then, $\nu$ can be decreased to make the QHWMA less biased as a gradient estimator, thus mitigating the aforementioned “staleness” problem. Note, however, that since decreasing $\nu$ will also increase $\rho$, we cannot simply decrease $\nu$ to zero. Specifically, any $\nu<1$ imposes a tight lower bound of $(1-\nu)^{2}$ on $\rho$, regardless of choice of $\beta$.

A.8 Momentum and QHM update rules

For completeness, we explicitly write the update rules for the momentum and QHM algorithms.

which can be efficiently written using an auxiliary buffer $g_{t}$ as:

which can be efficiently written using an auxiliary buffer $g_{t}$ as:

Comparing Eq. 2 and Eq. 4, QHM may seem at first glance identical to momentum with discount factor $\nu\beta$. However, replacing the $\beta$ in Eq. 6 with $\nu\beta$ yields:

which plainly differs from Eq. 7 – most notably, in the exponential discount factor ($\nu\beta$) for past gradients. Thus, momentum with discount factor $\nu\beta$ does not recover QHM.

A.9 Related work in variance reduction

Section 4 presents numerous connections to other optimization algorithms that shed light on both deterministic and stochastic convergence properties of QHM. However, we do not formally analyze the convergence properties of QHM from a variance reduction standpoint; this remains future work. Here, we briefly discuss other work in variance reduction.

Recently, much effort has been devoted towards reducing the variance of the stochastic gradients used in optimization algorithms. Perhaps the most widely-studied setting is the “finite sum”, or offline, stochastic optimization setting. Methods analyzed in the finite-sum setting include SAG (Schmidt et al. 2013), SAGA (Defazio et al. 2014), SVRG (Johnson & Zhang 2013), FSVRG (Shang et al. 2017), Katyusha (Allen-Zhu 2017), and others. We do not comment in detail on the finite sum setting due to its limited practical applicability to large-scale deep learning; for a fuller discussion of such methods, see Kidambi et al. 2018.

Some work in variance reduction has drawn an explicit connection to momentum. For example, Roux et al. 2018 propose a method involving Bayesian updates of gradient estimates, which induces adaptive gradient averaging. The authors note that this method boils down to momentum with an adaptive $\beta$.

Appendix B PID controllers and optimization

We follow Recht 2018 in describing the connection between PID control and gradient-based optimization.

We slightly adapt the setting from Aaström & Hägglund 1995. $t$ denotes time. There is a setpoint (i.e. target state), $r(t)$, and a process variable (i.e. current state), $y(t)$. The error of the system is defined as $e(t)\stackrel{{\scriptstyle\text{def}}}{{=}}r(t)-y(t)$. A “controller” outputs a control signal $u(t)$, usually towards the goal of making the error zero. The controller’s choice of $u(t)$ affects $y(t)$ in some unspecified manner.

A PID controller, parameterized by $k_{P}$, $k_{I}$, and $k_{D}$, uses the control function:

Here, the terms in the square brackets are typically referred to as the P, I, and D terms, respectively.

In discrete time, the setpoint, process variable, and error are trivially discretized as $r_{t}$, $y_{t}$, and $e_{t}\stackrel{{\scriptstyle\text{def}}}{{=}}r_{t}-y_{t}$, respectively. The I term, which we label $w_{t}$, is discretized as:

The D term, which we label $v_{t}$, could be discretized as $v_{t}=e_{t}-e_{t-1}$ (first differences). However, a low-pass filter is often applied to mitigate noise, thus resulting in:

We simplify exposition by considering $e_{-1}$, $w_{-1}$, and $v_{-1}$ to be $0$.

Finally, the PID control function Eq. 8 is trivially discretized as:

Recht 2018 relates optimization to PID control as follows:

That is, the process variable is the stochastic gradient, the controller’s goal is to make this gradient zero, and the controller achieves this by choosing the next step’s model parameters according to the update rule $\theta_{t+1}\leftarrow u_{t}+\theta_{0}$. The update rule for a PID control optimizer is thus:

Recht demonstrates that PID in this setting encapsulates gradient descent, momentum, and NAG; for example, gradient descent is recovered when $k_{P}=k_{D}=0$ and $k_{I}=\alpha$.

Finally, to provide some additional intuition, we can state the following fact about the D term ($v_{t}$):

Thus, the D term is simply a weighted sum of an EWMA of gradients (i.e. momentum buffer) and the current gradient, and a PID control optimizer’s output is simply a weighted sum of the momentum buffer, the current gradient, and the sum of all past gradients.

Appendix C Connections to other algorithms (in-depth)

This appendix presents a deeper theoretical treatment of Section 4.2 through Section 4.4, deriving and discussing connections between QHM and various other optimization algorithms.

For convenience, we impose the restriction that the output $\theta_{t}$ can only depend on the state $S_{t}$. Then, for analytical purposes, the optimizer can be written as the following update rule:

where $0_{p}$ denotes the size-$p$ zero vector, $\varnothing$ denotes throwaway values, and $\begin{bmatrix}v_{1}&v_{2}&\dots\end{bmatrix}$ denotes vector stacking.

Then, for $t>0$, we can write $\theta_{t}$ in terms of the initial state $S_{0,\left\{1\dots b\right\}}$ and all past gradients, using the last row of various matrix powers of ${\bm{A}}$:

C.2 QHM

The internal state of QHM includes two buffers: $g_{t}$ (momentum buffer) and $\theta_{t}$ (model parameters).

The transition matrix ${\bm{T}}_{\text{QHM}}$, mapping from $\begin{bmatrix}g_{t}&\theta_{t}&\nabla\hat{L}_{t}(\theta_{t})&0_{p}\end{bmatrix}^{\intercal}$ to $\begin{bmatrix}g_{t+1}&\theta_{t+1}&0_{p}&\theta_{t}\end{bmatrix}^{\intercal}$, is:

For $n>0$, routine computation yields the last row of the $(n+1)$-th matrix power:

Applying Eq. 10, the optimizer state $\theta_{t}$ can be written as:

In the typical case of $g_{0}=0$, we have:

C.3 PID

Recht 2018 draws a strong connection between gradient-based optimization and PID control. We regurgitate the excellent exposition (with minor modifications) in Appendix B.

The transition matrix ${\bm{T}}_{\text{PID}}$, mapping from $\begin{bmatrix}e_{t-1}&w_{t-1}&v_{t-1}&\theta_{0}&\nabla\hat{L}_{t}(\theta_{t})&0_{p}\end{bmatrix}^{\intercal}$ to $\begin{bmatrix}e_{t}&w_{t}&v_{t}&\theta_{0}&0_{p}&\theta_{t}\end{bmatrix}^{\intercal}$, is:

For $n>0$, routine computation yields the last row of the $(n+1)$-th matrix power:

Applying Eq. 10, the optimizer state $\theta_{t}$ can be written as:

In the typical case of $e_{-1}=w_{-1}=v_{-1}=0_{p}$, we have:

Then, equating with Eq. 11, we have that QHM is PID with: This is inconsistent with Recht 2018’s derivation by a factor of $(1-\beta)$ in $k_{P},k_{D}$ and $(1-\beta)/\beta$ in $k_{I}$. While $(1-\beta)$ is explainable as the difference between a normalized and unnormalized momentum buffer, we suspect that the extra factor of $\beta$ in $k_{I}$ is a mistake in the original derivation.

Viewing $\beta$ as a constant, the following restriction holds on the PID coefficients that QHM can recover:

This restriction is looser than those for plain SGD (which has the additional restriction $k_{P}=k_{D}=0$), momentum (which has the additional restriction $k_{P}/k_{I}=k_{D}/k_{P}$), and NAG (which has the additional restriction $k_{P}/k_{I}=\beta k_{D}/k_{P}$).

Viewing $\beta$ as a hyperparameter, QHM can recover all PID coefficients except when $k_{I}=0$ (i.e. P, D, or PD controller), or $k_{P}\neq 0=k_{D}$ (i.e. PI controller).

To summarize, PID is a superfamily of QHM. Viewing $\beta$ as a constant, QHM imposes a restriction on the ratio between $k_{P}$ and $k_{D}$. Viewing $\beta$ as a free variable, however, QHM can recover nearly all PID coefficients.

C.4 SNV

Section 6 of Lessard et al. 2016 describes a ‘‘synthesized Nesterov variant’’ algorithm, which we call ‘‘SNV’’ for convenience. This algorithm is used to analyze and improve optimizer robustness under ‘‘relative deterministic noise’’ (i.e. multiplicative noise of the gradient). This is similar to the vanishing gradient assumption used in Loizou & Richtárik 2017, which removes the need to consider variance reduction of the gradient.

The internal state of a SNV optimizer includes two buffers: $\xi_{t}$ and $\xi_{t-1}$.

The transition matrix ${\bm{T}}_{\text{SNV}}$, mapping from $\begin{bmatrix}\xi_{t}&\xi_{t-1}&\nabla\hat{L}_{t}(\theta_{t})&0_{p}\end{bmatrix}^{\intercal}$ to $\begin{bmatrix}\xi_{t+1}&\xi_{t}&0_{p}&\theta_{t}\end{bmatrix}^{\intercal}$, is:

For $n>0$, routine computation gives us the last row of the $(n+1)$-th matrix power:

Applying Eq. 10, the optimizer state $\theta_{t}$ can be written as:

Initialize $\xi_{0}=\xi_{-1}=\theta_{0}$. The optimizer state $\theta_{t}$ is:

Then, equating with Eq. 11, we have that QHM is SNV with:

To summarize, QHM and SNV recover each other. By extension, QHM recovers the Robust Momentum method, which is a specific parameterization of SNV (Cyrus et al. 2018). Moreover, since Robust Momentum recovers the Triple Momentum of Scoy et al. 2018, QHM also recovers Triple Momentum.

C.5 AccSGD

Jain et al. 2017 and Kidambi et al. 2018 point out various failures of momentum and NAG in the setting of stochastic least squares optimization. This motivates their proposal of the AccSGD algorithm, which yields faster convergence over momentum and NAG in certain least-squares regression settings. Here, we discuss the formulation of Kidambi et al. 2018.

AccSGD, parameterized by $\delta>0$, $\kappa>1$, $\xi\leq\sqrt{\kappa}$, and ${\epsilon}<1$, uses the update rule:

The internal state of an AccSGD optimizer includes two buffers: $\bar{w}_{t}$ (a buffer) and $w_{t}$ (the iterate, identical to $\theta_{t}$).

The transition matrix ${\bm{T}}_{\text{AccSGD}}$, mapping from $\begin{bmatrix}\bar{w}_{t}&w_{t}&\nabla\hat{L}_{t}(\theta_{t})&0_{p}\end{bmatrix}^{\intercal}$ to $\begin{bmatrix}\bar{w}_{t+1}&w_{t+1}&0_{p}&\theta_{t}\end{bmatrix}^{\intercal}$, is:

For $n>0$, routine computation gives us the last row of the $(n+1)$-th matrix power:

Applying Eq. 10, the optimizer state $\theta_{t}$ can be written as:

Fix ${\epsilon}\in(0,1)$, and initialize $\bar{w}_{0}=w_{0}=\theta_{0}$. The optimizer state $\theta_{t}$ is:

Then, equating with Eq. 11, we have that QHM is AccSGD with:

Based on the above analysis, NAG (i.e. $\nu=\beta$) is recovered when $\xi=\frac{1}{2{\epsilon}}\left(1-{\epsilon}+\sqrt{4\kappa+(1-{\epsilon})^{2}}\right)$. Empirical simulations confirm this finding. This disproves the claim in Kidambi et al. 2018 that AccSGD recovers NAG when $\xi=\sqrt{\kappa}$. In fact, we demonstrate that AccSGD cannot recover NAG at all. For ${\epsilon}\in(0,1)$ and the aforementioned value of $\xi$, we have that $\xi>\sqrt{\kappa}$:

Since AccSGD requires that $\xi\leq\sqrt{\kappa}$ and that ${\epsilon}\in(0,1)$ The recommended value for ${\epsilon}$ is 0.7 (Kidambi et al. 2018)., AccSGD cannot recover NAG.

To summarize, QHM recovers AccSGD. In the reverse direction, AccSGD does not recover QHM; specifically, we disprove the claim in Kidambi et al. 2018 that AccSGD recovers NAG. Since QHM recovers NAG, AccSGD cannot fully recover QHM.

Appendix D General two-state optimizer

To simplify further derivations we diagonalize ${\bm{T}}_{\text{TSO}}$ as:

If $\psi\neq 0$, $\phi\neq 0$, $\phi\leq 1$, $\frac{1}{2}(h+q+\phi)=1$, $h-q+\phi=0$, and $1-l=\frac{1}{2}(h+q-\phi)$, then QHM implements the TSO optimizer with:

We can write down the unrolled TSO update rule for $\theta_{t}$, as follows:

Thus, the unrolled update rule for QHM takes the following form:

Now we match the corresponding coefficients in both of the update rules to establish dependencies:

By solving the first equation we can establish values for $\alpha$, $\beta$, and $\nu$:

Per our assumption $({\bm{\Lambda}}_{\text{TSO}})_{3,3}=\frac{1}{2}(h+q+\phi)=1$ and $h-q+\phi=0$, we can recover the following relationships:

We can solve the second equation to find $g_{0}$:

Given that $({\bm{\Lambda}}_{\text{TSO}})_{3,3}=1$ and $h-q+\phi=0\implies h-q-\phi=-2\phi$, we can simplify:

Appendix E An alternative PID setting

We very briefly comment on An et al. 2018’s PID control setting.

An et al. 2018’s PID control optimizer, parameterized by $r,k_{D},\beta>0$, uses the following update rule: The exponential discount is $\alpha$ in the original paper; we use $\beta$ to avoid confusion.

This setting departs somewhat from typical PID control, in that the signal $u_{t}$ controls the derivative of the controller’s output (i.e. $\theta_{t+1}-\theta_{t}$) rather than the output itself (i.e. $\theta_{t+1}-\theta_{0}$). To avoid parameter blowup, this formulation necessitates the addition of exponential decay to the I term, with discount factor $\beta$. One final oddity is that the D term ($v_{t}$) calculates the negation of the derivative.

The I term thus becomes the momentum buffer. However, recall from B.1 that the D term is a weighted sum of the momentum buffer and the P term. It follows that the D term is a weighted sum of the P and I terms, and that this setting is degenerate (either “PI” or “PD”).

As a consequence, the proposed PID algorithm of An et al. 2018 is less expressive than that of Recht 2018. Specifically, applying B.1 demonstrates a mapping into QHM:

This PID control optimizer is costlier than QHM. It requires 2 auxiliary buffers of memory. Computationally, it requires 2 in-place scalar-vector multiplications and 5 scaled vector additions per update step.

Appendix F (QH)Adam’s update bound

This appendix elaborates on Adam and QHAdam’s stability properties through the lens of a step size upper bound.

It is well known that the training process for deep learning models can often ‘‘explode’’ due to a very small number of large parameter updates. With Adam, these large updates can occur if there exist parameters whose stochastic gradients are almost always near zero but incur rare ‘‘spikes’’. Somewhat more concretely, a stochastic gradient is “spiky” if its distribution has extremely large higher-order cumulants relative to its typical magnitudes.. This is because the square root of the second moment estimate, used in normalizing the gradient for the update step, will be far below the magnitude of these spikes.

There are three main ways to address this instability:

Firstly, one can simply decrease the learning rate $\alpha$. However, this may be undesirable due to slower training.

Secondly, one can increase the ${\epsilon}$ hyperparameter. However, the appropriate setting of ${\epsilon}$ depends on the exact magnitudes of these gradient spikes, which is often unknown. Setting ${\epsilon}$ too high effectively turns Adam into SGD. Thus, setting ${\epsilon}$ often reduces to guesswork.

Thirdly, one can clip gradients. However, the appropriate magnitude of the gradient clipping also depends on the stochastic gradient distribution. Thus, this solution also involves a fair amount of guesswork.

However, Adam does provide a useful guarantee – unlike SGD, Adam has an upper bound on the per-step update (Kingma & Ba 2015). This upper bound is independent of the gradient distribution (or even temporal correlation), depending only on the hyperparameters $\alpha$, $\beta_{1}$, and $\beta_{2}$. Thus, no matter the gradient distribution, Adam will restrict the magnitude of the per-step updates to some known constant. Kingma & Ba 2015 intuitively describe this bound as “establishing a trust region around the current parameter value”.

We show that the step size upper bound claimed in Section 2.1 of Kingma & Ba 2015 is incorrect, by providing the correct tight bound for both Adam and QHAdam. We then demonstrate that with QHAdam, one can lower the maximum per-step update (and thus improve stability) simply by lowering $\nu_{2}$ to be below 1.

We make two simplifications. Firstly, we fix ${\epsilon}=0$. The analysis with ${\epsilon}$ free follows the same approach but is somewhat messier. Secondly, we remove the bias correction of the moment estimators (i.e. we use $g_{t+1}^{\prime}\leftarrow g_{t+1}$ and $s_{t+1}^{\prime}\leftarrow s_{t+1}$).

In this setting, QHAdam applies the following update rule:

F.2 Implicit update bound

We now bound QHAdam’s update (before scaling by $\alpha$) by a constant dependent only on $\beta_{1}$, $\beta_{2}$, $\nu_{1}$, and $\nu_{2}$:

We perform the following simplification of Eq. 12 and Eq. 13:

Plugging the values of $x_{i}$ from Eq. 17 into Eq. 14 and Eq. 15 yields:

The desired result follows immediately. ∎

Consider the limit case of $t\rightarrow\infty$. Then, the bound in F.1 simplifies to:

For vanilla Adam (i.e. $\nu_{1}=\nu_{2}=1$), Eq. 18 simplifies further to:

Note that since the bound in Eq. 19 is tight, this result contradicts the claim in Section 2.1 of Kingma & Ba 2015 that Adam’s per-coordinate step size is bounded above by $\alpha\cdot\max\{1,(1-\beta_{1})/\sqrt{1-\beta_{2}}\}$. The difference can be rather large – for example, for the recommended Adam parameters of $\beta_{1}=0.9$ and $\beta_{2}=0.999$, Kingma & Ba 2015 claim an upper bound of $\lesssim 3.16\cdot\alpha$, while Eq. 19 implies a tight bound of $\lesssim 7.27\cdot\alpha$. In the following discussion, we use the correct bounds from Eq. 18 and Eq. 19.

F.3 Discussion

The recommended vanilla Adam setting of $\beta_{2}=0.999$ in Kingma & Ba 2015 makes the right-hand side of Eq. 19 to be large, and various work has employed Adam with a significantly lower $\beta_{2}$; e.g. 0.98 (Vaswani et al. 2017; Ott et al. 2018). We performed experiments on these models indicating that increasing $\beta_{2}$ far beyond 0.98 led to training explosion. We suspect that these instability issues are especially prevalent in settings with rare inputs or labels, such as machine translation. Decreasing $\beta_{2}$ is undesirable, often slowing down training. In proposing the AdamNC algorithm, Reddi et al. 2018 suggests that $\beta_{2}$ should be high to capture a sufficiently long history of past gradients. Moving from Adam to QHAdam, an alternative solution is to decrease $\nu_{2}$ to be below 1. This decreases the right-hand side of Eq. 18, up to a point, and thus imposes a tighter constraint on the magnitudes of updates than the vanilla Adam setting of $\nu_{2}=1$. Fig. 3 shows an example of this phenomenon using a fixed $\nu_{1}$, $\beta_{1}$, and $\beta_{2}$.

Appendix G Miscellaneous derivations

This appendix provides miscellaneous derivations that do not cleanly fit elsewhere.

Due to the independence assumption, the covariance matrix of the QHWMA for $t>0$ is simply:

The desired result follows immediately. ∎

We expand $v_{t}$ as follows, recalling that $v_{-1}=0$:

We then proceed by separating out the sum in Eq. 20, recalling that $e_{-1}=0$:

The desired result follows by substituting $e_{t}=-\nabla\hat{L}_{t}(\theta_{t})$ into Eq. 21. ∎

Appendix H QHM and Aggregated Momentum

We perform a brief empirical comparison of QHM and Aggregated Momentum (AggMo), proposed by Lucas et al. 2018. In short, we find that for an autoencoder task, we can take the optimal parameterization of AggMo from an extensive parameter sweep, and from that we can construct a QHM parameterization by hand which outperforms the optimal AggMo parameterization.

AggMo is a many-state optimizer that aggregates multiple momentum buffers in its update rule.

Intuitively, AggMo maintains $K$ unnormalized momentum buffers with different discount factors and uses the average of these buffers in the update rule.

H.2 Empirical comparison of QHM and AggMo

We perform the autoencoder experiments of Lucas et al. 2018 using the authors’ implementation, https://github.com/AtheMathmo/AggMo with two changes:

We replace the MNIST dataset (LeCun 1998) with the richer digits subset of the EMNIST dataset (Cohen et al. 2017). We hold out 10% of the training dataset for validation.

We change the minibatch size from 200 to 256 for computational efficiency.

Lucas et al. 2018 conduct a sweep over parameterizations of AggMo. Performing the same sweep, we find that the best parameterization of AggMo uses discount factors $\beta=[0,0.9,0.99,0.999]$ and learning rate $\gamma=0.1$. We name this parameterization “AggMo-Best”.

We now apply intuition to convert AggMo-Best into a QHM parameterization, which we name “QHM-Converted”. We calculate the effective step size $\alpha$ of AggMo-Best:

We round up and use $\alpha=28$ as the learning rate for QHM-Converted.

From Section 7.1, our rule of thumb for QHM is $\nu=0.7$ and $\beta=0.999$. However, noting that this rule of thumb is toward replacing momentum/NAG with discount factor 0.9, and observing that the best NAG parameterization reported by Lucas et al. 2018 uses discount factor 0.99, we instead use $\nu=0.97$ and $\beta=0.999$ for QHM-Converted.

In summary, the parameterization of QHM-Converted is $\alpha=28$, $\nu=0.97$, and $\beta=0.999$, and no optimization or parameter sweeps on this task were performed to construct this parameterization.

Fig. 4 and Table 4 present the performance of AggMo-Best and QHM-Converted on the autoencoder task. QHM-Converted outperforms AggMo-Best on the mean squared error (MSE) metric over the training, validation, and testing datasets.

H.3 Discussion

To recap, we take the optimal AggMo parameterization from an extensive sweep, we convert that parameterization by hand to one for QHM, and we find that the latter outperforms the former on this autoencoder task.

These results indicate that using multiple momentum buffers with an arbitrary weighting scheme (i.e. AggMo with $K>2$) provides negligible benefit over using a single slow-decaying momentum buffer with an appropriate weight (i.e. QHM with high $\beta$ and appropriate $\nu$).

Lucas et al. 2018 offer an interpretation of AggMo as passive damping for physical systems. In this interpretation, fast-decaying momentum buffers “dampen” the oscillations of slow-decaying momentum buffers by providing velocity in an opposite direction.

In this context and considering these results, we conjecture that the current gradient already provides adequate damping for a slow-decaying momentum buffer, and that the damping provided by additional momentum buffers is of marginal value.

Lucas et al. 2018 motivate this extension by the recovery of NAG. In fact, we observe that this extension, with $K=2$ and discount factors $[0,\beta]$, recovers QHM as well.

In independent preliminary experiments on different tasks, we found that various alternate weighting schemes of multiple momentum buffers (i.e. various parameterizations of extended AggMo with $K>2$) did not result in material improvements over the single momentum buffer. However, this preliminary investigation was neither rigorous nor conclusive. Lucas et al. 2018 do not empirically explore these alternate weighting schemes, and it is unclear how to do so both comprehensively and efficiently, since the number of hyperparameters scales linearly with the number of momentum buffers $K$.

Toward improving the usability of extended AggMo, we suggest as future work to investigate theoretically grounded or empirically tractable methods to determine good weighting schemes for extended AggMo. However, given the added costs and complexity of AggMo (both standard and extended), we surmise in the meantime that QHM may be preferable for most practical applications.

Appendix I Full details of experimental setup

All experiments use Python 3.7 and PyTorch 0.4.1 (Paszke et al. 2017). Experiments are run on a mix of NVIDIA P100 and V100 GPUs, along with a mix of CUDA 9.0 and 9.2.

I.1 Parameter sweep experiments

Training occurs over 90 epochs (minibatch size 64). The first epoch uses linear warmup of the learning rate $\alpha$ (i.e. $\alpha$ starts from zero and grows to its “regular” value by the end of the epoch). Each training run uses a single GPU.

Each parameterization is run 3 times with different seeds, and we report training loss, training top-1 error, and validation top-1 error.

We use a step decay schedule for the learning rate: $\alpha\in\{1,0.1,0.01\}$. That is, the first 30 epochs use $\alpha=1.0$, the next 30 epochs use $\alpha=0.1$, and the final 30 epochs use $\alpha=0.01$. These learning rates may seem high, but recall that the effective step size is identical to that of “typical”, unnormalized momentum/NAG with $\alpha\in\{0.1,0.01,0.001\}$ and $\beta=0.9$.

We sweep over $\nu$ and $\beta$ using the following two-dimensional grid:

Note that this grid encapsulates numerous parameterizations of plain SGD, momentum, and NAG (specifically, all parameterizations with the $\beta$ values enumerated above).

We fix $\alpha=0.001$, $\beta_{2}=0.999$, and ${\epsilon}=10^{-8}$, as suggested in Kingma & Ba 2015. We also fix $\nu_{2}=1$.

We sweep over $\nu_{1}$ and $\beta_{1}$ using the same grid as for QHM’s $\nu$ and $\beta$.

I.1.1 Experiment: Logistic-EMNIST-QHM

The model is multinomial logistic regression with pixel vector input.

The task is digit recognition over the EMNIST dataset – specifically, the digits subset (Cohen et al. 2017).

The model is optimized with QHM. The optimization objective is cross-entropy loss, plus L2 regularization with coefficient $\frac{1}{2}\cdot 10^{-4}$.

I.1.2 Experiment: Logistic-EMNIST-QHAdam

The model is optimized with QHAdam. The optimization objective is the same as in Logistic-EMNIST-QHM.

I.1.3 Experiment: MLP-EMNIST-QHM

The model is a multilayer perceptron (specifically, 3 layer feed forward network) with pixel vector input. The hidden layer sizes are 200, 100, and 50 units, and all hidden units are $\tanh$ non-linearities. The final layer is followed by softmax.

I.1.4 Experiment: MLP-EMNIST-QHAdam

I.1.5 Experiment: RN18-CIFAR10-QHM

The model is a 18-layer convolutional residual network with preactivations (He et al. 2016b).

The task is image recognition on the CIFAR-10 dataset (Krizhevsky 2009).

The model is optimized with QHM. The optimization objective is cross-entropy loss, plus L2 regularization with coefficient $\frac{1}{2}\cdot(5\cdot 10^{-4})$.

The implementation generally follows Liu 2017. Data augmentation includes horizontal flipping at random, as well as random 32-pixel crops with 4-pixel padding. For batch normalization (Ioffe & Szegedy 2015), we use online calculation of moments with $0.99$ exponential decay.

I.1.6 Experiment: RN50-ImageNet-QHM

The model is a 50-layer convolutional residual network (He et al. 2016a).

The task is image recognition on the ILSVRC2012 (“ImageNet”) 1000-class dataset (Russakovsky et al. 2015).

The model is optimized with QHM. The optimization objective is cross-entropy loss, plus L2 regularization with coefficient $\frac{1}{2}\cdot 10^{-4}$.

The implementation generally follows Paszke et al. 2016. Data augmentation includes horizontal flipping at random, as well as random 224-pixel crops. Validation is performed on 224-pixel center crops. For batch normalization, we use online calculation of moments with $0.99$ exponential decay. The model is trained with half-precision floating point.

I.2 Case studies

The model is a 152-layer convolutional residual network (He et al. 2016a).

We use the baseline configuration (NAG with size-256 minibatches) described in Goyal et al. 2017. Specifically, the learning rate schedule is $\alpha=0.1$ for the first 30 epochs, $\alpha=0.01$ for the next 30 epochs, $\alpha=0.001$ for the next 20 epochs, and $\alpha=0.0001$ for the final 10 epochs. The optimization objective is cross-entropy loss, plus L2 regularization with coefficient $\frac{1}{2}\cdot 10^{-4}$. The only departure from Goyal et al. 2017 is that we employ a first-epoch linear warmup of $\alpha$ (as in the parameter sweep experiments).

The non-baseline optimizer is QHM with $\nu=0.7$ and $\beta=0.999$. Following Section 7.1, we increase the learning rate ($\alpha$) 10-fold. All other details are identical to the baseline.

For each optimizer, we run 3 seeds and report validation top-1 error.

See RN50-ImageNet-QHM for implementation details.

I.2.2 Experiment: FConvLM-WikiText103-QHM

The model is the GCNN-14 variant of the gated convolutional language model described in Dauphin et al. 2016.

The task is language modeling on the WikiText-103 language dataset (Merity et al. 2016).

For the baseline, we use the configuration described in Dauphin et al. 2016. Specifically, the model is optimized with 60 epochs of NAG ($\beta=0.99$). We initialize the learning rate to $\alpha=1.0$, and we halve it when validation loss begins to increase. The optimization objective is adaptive cross-entropy, plus direct weight decay with coefficient $5\cdot 10^{-6}$. We also clip gradient norm with maximum norm of 0.1.

The non-baseline optimizer is QHM with $\nu=0.98$ and $\beta=0.998$. Following Section 7.1, we increase the initial learning rate ($\alpha$) 100-fold. All other details are identical to the baseline.

For each optimizer, we run 10 seeds and report validation perplexity.

The implementation is exactly that of fairseq-py (Gehring et al. 2017). We train each model on 8 GPUs with half-precision floating point.

I.2.3 Experiment: TD3-MuJoCo-QHAdam

We use the Twin Delayed Deep Deterministic Policy Gradients (TD3) algorithm (Fujimoto et al. 2018) for actor/critic learning. Both the actor and the critic are represented as multilayer perceptrons.

We use a suite of MuJoCo continuous control tasks (Todorov et al. 2012). In particular, we perform evaluation on the following environments: HalfCheetah, Hopper, Walker2d, Ant, Reacher, InvertedPendulum, and InvertedDoublePendulum.

For the baseline, we use Adam with the default parameters ($\alpha=0.001$, $\beta_{1}=0.9$, $\beta_{2}=0.999$, and $\epsilon=10^{-8}$) as in Fujimoto et al. 2018. We train for $10^{6}$ iterations.

The non-baseline optimizer is QHAdam. We set $\nu_{1}=0.9$, $\nu_{2}=1$, and otherwise leave the baseline setting unchanged.

For each optimizer, we run 10 seeds. For each seed, we report average reward (on 10 episodes) every 5000 iterations of training, following Fujimoto et al. 2018.

We use Fujimoto et al. 2018’s open-sourced implementation https://github.com/sfujim/TD3, along with version 2 of OpenAI Gym (Brockman et al. 2016).

I.2.4 Experiment: TF-WMT16ENDE-QHAdam

We use a Transformer-based model (Vaswani et al. 2017) described in Ott et al. 2018.

We train our models on a filtered version of the WMT16 English-German machine translation dataset as in Vaswani et al. 2017, and evaluate on newstest14 for English-German. Our evaluation setup is identical to the one in Ott et al. 2018.

For the baseline, we use Adam ($\beta_{1}=0.9$, $\beta_{2}=0.98$, and $\epsilon=10^{-8}$) as in Ott et al. 2018, training over $70$ epochs. We use the same learning rate schedule as in Vaswani et al. 2017 and Ott et al. 2018. Specifically, we increase the learning rate from $10^{-7}$ to $10^{-3}$ linearly for 4000 steps, then decay it proportionally to the inverse square root of the number of steps. We optimize the label smoothed cross-entropy loss as in Vaswani et al. 2017, with label smoothing of 0.1.

We use QHAdam ($\nu_{1}=0.8$, $\beta_{1}=0.95$, $\nu_{2}=0.7$, $\beta_{2}=0.98$, and $\epsilon=10^{-8}$) as a non-baseline optimizer. The other settings are identical to the baseline.

For each optimizer, we run 10 seeds and report validation perplexity and validation BLEU scores. We observe that 4 seeds for the baseline Adam optimizer “explode” (fail to converge). Thus, we only consider the 6 best seeds for each optimizer.

We use Ott et al. 2018’s open-sourced implementation in fairseq-py (Gehring et al. 2017). We train each model on 8 GPUs with half-precision floating point. Note that Ott et al. 2018 uses 128 GPUs; to eliminate this discrepancy and precisely reproduce the training environment, we accumulate gradients over 16 minibatches before each optimization step.

Appendix J Full parameter sweep results

Fig. 5 shows summary graphs for all parameter sweep experiments. These summary graphs display selected parameterizations and optimal parameterizations of both the vanilla and QH algorithms. Full details of experimental settings can be found in Appendix I.

Since each experimental setting contains nearly 200 parameterizations with 3 seeds each, we cannot fully present the data with graphs or tables. Thus, we provide data files describing all runs in CSV format. https://github.com/facebookresearch/qhoptim/releases/download/emptytag/qhoptim_parameter_sweep_data.tar.gz