Meta-descent for Online, Continual Prediction

TL;DR

This paper explores vector step-size adaptation methods for online, non-stationary prediction, introducing a new meta-descent algorithm called AdaGain that outperforms traditional methods in various scenarios.

Contribution

The paper introduces AdaGain, a general meta-descent algorithm for step-size adaptation applicable to diverse online prediction algorithms, especially in non-stationary environments.

Findings

Meta-descent methods outperform quasi-second order methods in non-stationary tasks.

AdaGain demonstrates robustness and competitive performance on real-world data.

Both families of methods can perform well, with meta-descent showing particular advantages.

Abstract

This paper investigates different vector step-size adaptation approaches for non-stationary online, continual prediction problems. Vanilla stochastic gradient descent can be considerably improved by scaling the update with a vector of appropriately chosen step-sizes. Many methods, including AdaGrad, RMSProp, and AMSGrad, keep statistics about the learning process to approximate a second order update---a vector approximation of the inverse Hessian. Another family of approaches use meta-gradient descent to adapt the step-size parameters to minimize prediction error. These meta-descent strategies are promising for non-stationary problems, but have not been as extensively explored as quasi-second order methods. We first derive a general, incremental meta-descent algorithm, called AdaGain, designed to be applicable to a much broader range of algorithms, including those with semi-gradient updates or even those with accelerations, such as RMSProp. We provide an empirical comparison of methods from both families. We conclude that methods from both families can perform well, but in non-stationary prediction problems the meta-descent methods exhibit advantages. Our method is particularly robust across several prediction problems, and is competitive with the state-of-the-art method on a large-scale, time-series prediction problem on real data from a mobile robot.

Equations

$${\mathbf{w}}_{t+1}={\mathbf{w}}_t+{\mathbf{\alpha }}_t\circ {\Delta }_t$$

$$\frac{\partial \ell ({\mathbf{w}}_t(\mathbf{\alpha }))}{\partial {\alpha }_i}=\sum _j^k\frac{\partial \ell ({\mathbf{w}}_t(\mathbf{\alpha }))}{\partial w_{t,j}}\frac{\partial w_{t,j}}{\partial {\alpha }_i}.$$

$$Y_t\stackrel{\text{makebox}[0.0pt]\text{mbox}def}{=}{Z}_t+\mathcal{N}(0,{\sigma }_{Y,t}^2),Z_{t+1}\leftarrow Z_t+\mathcal{N}(0,{\sigma }_{Z,t}^2).$$

$$\min_{\boldsymbol{\alpha}>0}\mathbb{E}\left[\|\Delta_{t}(\mathbf{w}_{t}(\boldsymbol{\alpha}))\|_{2}^{2}\ \big{|}\ \mathbf{w}_{0}\right].$$

$$\frac{\frac{1}{2}\partial \Vert {\Delta }_t({\mathbf{w}}_t(\mathbf{\alpha })){\Vert }_2^2}{\partial {\alpha }_i}$$

$$={\Delta }_t({\mathbf{w}}_t(\mathbf{\alpha }){)}^{\top }\sum _j^k\frac{\partial {\Delta }_t({\mathbf{w}}_t(\mathbf{\alpha }))}{\partial w_{t,j}}\frac{\partial w_{t,j}}{\partial {\alpha }_i}.$$

$${\mathbf{\psi }}_{t+1,i}$$

$$\displaystyle=\boldsymbol{\psi}_{t,i}+\boldsymbol{\alpha}\circ\sum_{j}\frac{\partial\Delta_{t}(\mathbf{w}_{t}(\boldsymbol{\alpha}))}{\partial w_{t,j}}\frac{\partial w_{t,j}}{\partial\alpha_{i}}+\bigg{[}\!\!\begin{array}[]{c}\mathbf{0}\\ \Delta_{t,i}(\boldsymbol{\alpha})\\ \mathbf{0}\end{array}\!\!\bigg{]}$$

$$\displaystyle=(\mathbf{I}+\text{diag}(\boldsymbol{\alpha})\mathbf{G}_{t})\boldsymbol{\psi}_{t,i}+\bigg{[}\!\!\begin{array}[]{c}\mathbf{0}\\ \Delta_{t,i}(\boldsymbol{\alpha})\\ \mathbf{0}\end{array}\!\!\bigg{]},$$

$${\mathbf{\alpha }}_t$$

$${\mathbf{\psi }}_{t+1,i}$$

$$\displaystyle=\boldsymbol{\psi}_{t,i}+\boldsymbol{\alpha}\circ\mathbf{G}_{t,i}(\boldsymbol{\psi}_{t,i})_{i}+\bigg{[}\!\!\begin{array}[]{c}\mathbf{0}\\ \Delta_{t,i}(\boldsymbol{\alpha})\\ \mathbf{0}\end{array}\!\!\bigg{]}.$$

$$\frac{\frac{1}{2}\partial \Vert {\Delta }_t({\mathbf{w}}_t(\mathbf{\alpha })){\Vert }_2^2}{\partial {\alpha }_i}$$

$$\approx {\Delta }_t({\mathbf{w}}_t(\mathbf{\alpha }){)}^{\top }\frac{\partial {\Delta }_t({\mathbf{w}}_t(\mathbf{\alpha }))}{\partial w_{t,i}}\frac{\partial w_{t,i}}{\partial {\alpha }_i}$$

$$={\hat{\psi }}_{t,i}{\mathbf{G}}_{t,i}^{\top }{\Delta }_t({\mathbf{w}}_t(\mathbf{\alpha }))$$

$${\mathbf{\alpha }}_t$$

$${\hat{\mathbf{\psi }}}_{t+1}$$

$$\frac{\partial \ell (\mathbf{w}(\mathbf{\alpha }))}{\partial {\alpha }_i}=\sum _j^k\frac{\partial \ell (\mathbf{w}(\mathbf{\alpha }))}{\partial w_{t,j}}\frac{\partial w_{t,j}}{\partial {\alpha }_i}$$

$${\mathbf{g}}_{t,j}$$

$${\mathbf{\psi }}_{t,i}$$

$${\mathbf{\psi }}_{t+1,i}$$

$$\displaystyle=\boldsymbol{\psi}_{t,i}+\boldsymbol{\alpha}\circ\sum_{j}\frac{\partial\mathbf{g}_{t}}{\partial w_{t,j}}\frac{\partial w_{t,j}}{\partial\alpha_{i}}+\bigg{[}\!\!\begin{array}[]{c}\mathbf{0}\\ \mathbf{g}_{t,i}(\boldsymbol{\alpha})\\ \mathbf{0}\end{array}\!\!\bigg{]}$$

$$\displaystyle=\boldsymbol{\psi}_{t,i}-\boldsymbol{\alpha}\circ(\mathbf{H}_{t}\boldsymbol{\psi}_{t,i})+\bigg{[}\!\!\begin{array}[]{c}\mathbf{0}\\ \mathbf{g}_{t,i}(\boldsymbol{\alpha})\\ \mathbf{0}\end{array}\!\!\bigg{]}$$

$$\displaystyle=(\mathbf{I}-\text{diag}(\boldsymbol{\alpha})\mathbf{H}_{t})\boldsymbol{\psi}_{t,i}+\bigg{[}\!\!\begin{array}[]{c}\mathbf{0}\\ \mathbf{g}_{t,i}(\boldsymbol{\alpha})\\ \mathbf{0}\end{array}\!\!\bigg{]}.$$

$${\mathbf{\alpha }}_t$$

$$\text{ for }({\mathbf{\Psi }}_t{)}_{:,i}={\mathbf{\psi }}_{t,i}\text{ with }{\mathbf{\Psi }}_t\in {\mathbb{R}}^{k\times k}$$

$${\mathbf{H}}_t$$

$${\mathbf{\psi }}_{t+1,i}$$

$$\displaystyle=\boldsymbol{\psi}_{t,i}-\boldsymbol{\alpha}\circ\mathbf{H}_{t,i}(\boldsymbol{\psi}_{t,i})_{i}+\bigg{[}\!\!\begin{array}[]{c}\mathbf{0}\\ \mathbf{g}_{t,i}(\boldsymbol{\alpha})\\ \mathbf{0}\end{array}\!\!\bigg{]}.$$

$${\hat{\mathbf{h}}}_t\stackrel{\text{makebox}[0.0pt]\text{mbox}def}{=}\left[\frac{{\partial }^2\ell (\mathbf{w}(\mathbf{\alpha })}{\partial {\mathbf{w}}_{t,1}^2},\dots ,\frac{{\partial }^2\ell (\mathbf{w}(\mathbf{\alpha })}{\partial {\mathbf{w}}_{t,k}^2}\right]$$

$$\frac{\partial \ell (\mathbf{w}(\mathbf{\alpha }))}{\partial {\alpha }_i}$$

$$\approx \frac{\partial \ell (\mathbf{w}(\mathbf{\alpha }))}{\partial w_{t,i}}\frac{\partial w_{t,i}}{\partial {\alpha }_i}$$

$$={\hat{\psi }}_{t,i}{\mathbf{g}}_{t,i}$$

$${\mathbf{\alpha }}_t$$

$${\hat{\mathbf{\psi }}}_{t+1}$$

$${\mathbf{\alpha }}_t$$

$${\hat{\mathbf{\psi }}}_{t+1}$$

$${\mathbf{w}}_{t+1}={\mathbf{w}}_t+\mathbf{\alpha }\circ {\Delta }_t$$

Full text

Introduction

In this paper we consider continual, non-stationary prediction problems. Consider a learning system whose objective is to learn a large collection of predictions about an agent’s future interactions with the world. The predictions specify the value of some signal many steps in the future, given that the agent follows some specific course of action. There are many examples of such prediction learning systems including Predictive State Representations (?), Observable Operator Models (?), Temporal-difference Networks (?), and General Value Functions (?). In our setting, the agent continually interacts with the world, making new predictions about the future, and revising its previous predictions as new outcomes are revealed. Occasionally, partially due to changes in the world and partially due to changes in the agent’s own behaviour, the targets may change and the agent must refine its predictions. 111We exclude recent meta-learning frameworks (MAML (?), LTLGDGD (?)) because they assume access to a collection of tasks that can be sampled independently, enabling the agent to learn how to select meta-parameters for a new problem. In our setting, the agent must solve a large collection of non-stationary prediction problems in parallel using off-policy learning methods.

Stochastic gradient descent (SGD) is a natural choice for our setting because gradient descent methods work well when paired with abundant training data. The performance of SGD is dependent on the step-size parameter (scalar, vector or matrix), which scales the gradient to mitigate sample variance and improve data efficiency. Most modern large-scale learning systems make use of optimization algorithms that attempt to approximate stochastic second-order gradient descent to adjust both the direction and magnitude of the descent direction, with early work indicating the benefits of such quasi-second order methods if used carefully in the stochastic case (?; ?). Many of these algorithms attempt to approximate the diagonal of the inverse Hessian, which describes the curvature of the loss function, and so maintain a vector of step-sizes—one for each parameter. Starting from AdaGrad (?; ?), several diagonal approximations have been proposed, including RmsProp (?), AdaDelta (?), vSGD (?), Adam (?) and AmsGrad (?). Stochastic quasi-second order updates have been derived specifically for temporal difference learning, with some empirical success (?), particularly in terms of parameter sensitivity (?; ?). On the other hand, second order methods, by design, assume the loss and thus Hessian are fixed, and so non-stationary dynamics or drifting targets could be problematic.

A related family of optimization algorithms, called meta-descent algorithms, were developed for continual, online prediction problems. These algorithms perform meta-gradient descent adapting a vector of step-size parameters to minimize the error of the base learner, instead of approximating the Hessian. Meta-descent applied to the step-size was first introduced for online least-mean squares methods (?; ?; ?; ?; ?), including the linear complexity method IDBD (?). IDBD was later extended to more general losses (?) and to support (semi-gradient) temporal difference methods (?; ?; ?). These methods are well-suited to non-stationary problems, and have been shown to ignore irrelevant features. The main limitation of several of these meta-descent algorithms, however, is that the derivations are heuristic, making it difficult to extend to new settings beyond linear temporal difference learning. The more general approaches, like Stochastic Meta-Descent (SMD) (?), require the update to be a stochastic gradient descent update and have some issues in biasing towards smaller step-sizes (?). It remains an open challenge to make these meta-descent strategies as broadly and easily applicable as the AdaGrad variants.

In this paper we introduce a new meta-descent algorithm, called AdaGain, that attempts to optimize the stability of the base learner, rather than convergence to a fixed point. AdaGain is built on a generic derivation scheme that allows it to be easily combined with a variety of base-learners including SGD, (semi-gradient) temporal-difference learning and even optimized SGD updates, like AMSGrad. Our goal is to investigate the utility of both meta-descent methods and the more widely used quasi-second order optimizers in online, continual prediction problems.We provide an extensive empirical comparison on (1) canonical optimization problems that are difficult to optimize with large flat regions (2) an online, supervised tracking problem where the optimal step-sizes can be computed, (3) a finite Markov Decision Process with linear features that cause conventional temporal difference learning to diverge, and (4) a high-dimensional time-series prediction problem using data generated from a real mobile robot. In problems with non-stationary dynamics the meta-descent methods can exhibit an advantage over the quasi-second order methods. On the difficult optimization problems, however, meta-descent methods fail, which, retrospectively, is unsurprising given the meta-optimization problem for stepsizes is similarly difficult to optimize. We show that AdaGain can possess the advantages of both families — performing well on both optimization problems with flat regions as well as non-stationary problems — by selecting an appropriate base learner, such as RMSProp.

Background and Notation

In this paper we consider online continual prediction problems modeled as non-stationary, uncontrolled dynamical systems. On each discrete time step $t$, the agent observes the internal state of the system through an imperfect summary vector $\mathbf{o}_{t}\in\mathcal{O}\in\mathbb{R}^{d}$ for some $d\in\mathbb{N}$, such as the sensor readings of a mobile robot. On each step, the agent makes a prediction about a target signal $T_{t}\in\mathbb{R}$. In the simplest case, the target of the prediction is a component $i$ of the observation vector on the next step $T_{t}=\mathbf{o}_{t+1,i}$—the classic one-step prediction. In the more general case, the target is constructed by mapping the entire future of the observation time series to a scalar, such as the discounted sum formulation used in reinforcement learning: $T_{t}=\mathbb{E}[\sum_{k=0}^{\infty}\gamma^{k}\mathbf{o}_{t+k+1,i}]$, where $\gamma\in[0,1)$ discounts the contribution of future observations to the infinite sum. The prediction $P_{t}\in\mathbb{R}$ is generated by a parametrized function, with modifiable parameter vector $\mathbf{w}_{t}\in\mathbb{R}^{k}$.

In online continual prediction problems the agent updates its predictions (via $\mathbf{w}_{t}$) with each new sample $\mathbf{o}_{t}$, unlike the more common batch and stochastic settings. The agent’s objective is to minimize the error between the prediction $P_{t}$ given by $\mathbf{w}_{t}$ and the target $T_{t}$ before it is observed, over all time steps. Online continual prediction problems are typically solved using stochastic updates to adapt the parameter vector $\mathbf{w}_{t}$ after each time step $t$ to reduce the error (retroactively) between $P_{t}$ and $T_{t}$. Generically, for stochastic update vector $\Delta_{t}\in\mathbb{R}^{d}$, the weights are modified

[TABLE]

for a vector step-size $\boldsymbol{\alpha}_{t}$, where the operator $\circ$ denotes element-wise multiplication. Given an update vector, the goal is to select $\boldsymbol{\alpha}_{t}$ to reduce error, into the future. Semi-gradient methods like temporal difference learning follow a similar scheme, but $\Delta_{t}$ is not the gradient of an objective function.

Step-size adaptation for the stationary setting is often based on estimating second-order updates.222A related class of algorithms are natural gradient methods, which aim to be robust to the functional parametrization. Incremental natural gradient methods have been proposed (?), including for policy evaluation with gradient TD methods (?). However, these algorithms do not remove the need select a step-size, and so we do not consider them further here. The idea is to estimate the loss function $\ell:\mathbb{R}^{d}\rightarrow\mathbb{R}$ locally around the current weights $\mathbf{w}_{t}$ using a second-order Taylor series approximation—which requires the Hessian $\mathbf{H}_{t}$. A closed-form solution can then be obtained for the approximation, because it is a quadratic function, giving the next candidate solution $\mathbf{w}_{t+1}=\mathbf{w}_{t}-\left(\mathbf{H}_{t}\right)^{-1}\nabla\ell(\mathbf{w}_{t})$. If instead the Hessian is approximated—such as with a diagonal approximation—then we obtain quasi-second order updates. Taken to the extreme, with the Hessian approximated by a scalar, as $\mathbf{H}_{t}=\alpha_{t}^{-1}\mathbf{I}$, we obtain first-order gradient descent with a step-size of $\alpha_{t}$. For the batch setting, the gains from second order methods are clear, with a convergence rate333There is a large literature on accelerated first-order descent methods, starting from early work on momentum (?) and many since focused mainly on variance reduction (c.f. (?)). These methods can complement step-size adaptation, but are not well-suited to non-stationary problems because many of the algorithms are designed for a batch of data and focus on increasing convergence rate to a fixed minimum. of $O(1/t^{2})$, as opposed to $O(1/t)$ for first-order descent.

These gains are not as clear in the stochastic setting, but diagonal approximations appear to provide an effective balance between computation and convergence rate improvements (?). ?  (?) provide a general regret analysis for diagonal approximations methods proving sublinear regret if step-sizes decrease to zero overtime. One algorithm, AdaGrad, uses the vector step-size $\boldsymbol{\alpha}_{t}=\eta(\sum_{i=1}^{t}\Delta_{t}+\epsilon)^{-1}$ for a fixed $\eta>0$ and a small $\epsilon>0$, with element-wise division. RMSProp and Adam—which are not guaranteed to obtain sublinear regret—use a running average rather than a sum of gradients, with Adam additionally including a momentum term for faster convergence. AMSGrad is a modification of Adam, that satisfies the regret criteria, without decaying the step-sizes as aggressively as AdaGrad.

The meta-descent strategies instead directly learn step-sizes that minimize the same objective as the base learner. A simpler set of such methods, called hypergradient methods (?; ?; ?), only adjust the step-size based on its impact on the weights on a single step. Hypergradient Descent (HD) (?) takes the gradient of the loss $\ell(\mathbf{w})$ w.r.t. a scalar step-size $\alpha>0$, to get the meta-gradient for the step-size as $\partial\ell(\mathbf{w}_{t})/\partial\alpha=-\nabla_{\mathbf{w}}\ell(\mathbf{w}_{t-1})^{\top}\nabla_{\mathbf{w}}\ell(\mathbf{w}_{t})$. The update simply requires storing the vector $\mathbf{g}_{t-1}=\nabla_{\mathbf{w}}\ell(\mathbf{w}_{t-1})$ and updating $\alpha_{t+1}=\alpha_{t}+\bar{\alpha}\mathbf{g}_{t-1}^{\top}\mathbf{g}_{t}$, for a meta step-size $\bar{\alpha}>0$. More generally, meta-descent methods, like IDBD (?) and SMD (?), consider the impact of the step-size back in time, through the weights, with $w_{t,j}$ the $j$-th element in vector $\mathbf{w}_{t}$

[TABLE]

The goal is to approximate this gradient efficiently, usually using a recursive strategy. We derive such a strategy for AdaGain below using a different meta-descent objective, and for completeness include the derivation for the SMD objective in the appendix (as the original contains an error).

Illustrative example

To make the problem more concrete, consider a simple state-less tracking problem driven by two interacting Gaussians:

[TABLE]

where the agent only observes the sequence $Y_{1},Y_{2},\ldots$. The objective is minimize mean squared error (MSE) between a scalar prediction $P_{t}=w_{t}$ and the target $T_{t}=Y_{t+1}$. This problem is non-stationary because $\sigma_{Y,t}$ and $\sigma_{Z,t}$ change periodically and the agent has no knowledge of the schedule. Since $\sigma_{Y,t}$ and $\sigma_{Z,t}$ govern how quickly the mean $Z_{t}$ drifts and the sampling variance in $Y_{t}$, the agent must step its step-size accordingly: larger $\sigma_{Z,t}$ requires larger stepsize, larger $\sigma_{Y,t}$ requires a smaller step-size. The agent must continually change its scalar step-size value in order to achieve low MSE. The optimal constant scalar step-size can be computed in this simple domain (?), and is shown by the black dashed line in Figure 1. We compared the step-sizes learned by several well-know quasi-second order methods (AdaGrad, RMSProp, Adadelta) and three meta-descent strategies including our own AdaGain. We ran the experiment for over 24 hours to test the robustness of these methods in a long-running continual prediction task. Several methods including AdaGain were able to match the optimal step-size. However, several well-known methods including AdaGrad and AdaDelta completely fail in this problem. In addition, the meta-descent strategy SMD diverged after 8183817 time steps, highlighting the special challenges of online, continual prediction problems.

Adaptive Gain for Stability

Tracking—continually updating the weights with recent experience—contrasts the typical goal of convergence. Much of the previous algorithm development for step-size adaptation, however, has been towards the aim of convergence, with algorithms like AdaGrad and AMSGrad that decay step-sizes over time. Assuming finite representational capacity, there may be aspects of the problem that can never be accurately modeled or predicted by the agent. In these partially observable problems tracking and thus treating the problem as if it were non-stationary can improve prediction accuracy compared with methods that converge (?). In continual learning we assume the agent’s task partially observable in this way, and develop a new step-size method that can facilitate tracking.

We treat the learning system as a dynamical system—where the weight update is based on stochastic updates known to suitably track the targets—and consider the choice of step-size as the inputs to the system to maintain stability. Such a view has been previously considered under adaptive gain for least-mean squares (LMS) (?, Chapter 4), where weights are treated as state following a random drift. To generalize this idea to other incremental algorithms, we propose a more general criteria based on the magnitude of the update vector.

A criteria for $\boldsymbol{\alpha}$ to maintain stability in the system is to keep the norm of the update vector small

[TABLE]

The update $\Delta_{t}(\mathbf{w}_{t}(\boldsymbol{\alpha}))$ on this time step is dependent on the step-size $\boldsymbol{\alpha}$ because that step-size influences $\mathbf{w}_{t}$ and past updates. The expected value is over all possible update vectors $\Delta_{t}(\mathbf{w}_{t}(\boldsymbol{\alpha}))$ for the given step-size and assuming the system started with some $\mathbf{w}_{0}$. If the dynamics are ergodic, $\Delta_{t}(\mathbf{w}_{t}(\boldsymbol{\alpha}))$ does not depend on the initial $\mathbf{w}_{0}$, and is only driven by the underlying state dynamics and the choice of $\boldsymbol{\alpha}$. The step-size can be seen as a control input for this system, with the goal to maintain a stable dynamical system by minimizing $\|\Delta_{t}(\mathbf{w}_{t}(\boldsymbol{\alpha}))\|_{2}^{2}$ over time.

We derive an algorithm to estimate $\boldsymbol{\alpha}$ for this dynamical system, which we call AdaGain: Adaptive Gain for Stability. The algorithm is derived for a generic update $\Delta_{t}(\mathbf{w}_{t}(\boldsymbol{\alpha}))$ that is differentiable w.r.t. the weights $\mathbf{w}_{t}$; we provide specific examples for particular updates in the appendix, including for linear TD.

Generic algorithm with quadratic-complexity

We derive the full quadratic-complexity algorithm to start, and then introduce approximations to obtain a linear-complexity algorithm. To minimize (4), we use stochastic gradient descent, and thus need to compute the gradient of $\|\Delta_{t}(\mathbf{w}_{t}(\boldsymbol{\alpha}))\|_{2}^{2}$ w.r.t. the step-size $\boldsymbol{\alpha}$. For step-size $\alpha_{i}$ as the $i$th element in the vector $\boldsymbol{\alpha}$, and $w_{t,j}$ the $j$-th element in vector $\mathbf{w}_{t}$

[TABLE]

The key, then, is to track how a change in the weights impacts the update and how changes in the step-size impact the weights. The first term can be computed instantaneously on this step. For the second term, however, the impact of the step-size on the weights goes back further to previous updates. We show how to obtain a recursive form for this step-size gradient, $\boldsymbol{\psi}_{t,i}\mathrel{\overset{\makebox[0.0pt]{\mbox{def}}}{=}}\frac{\partial\mathbf{w}_{t}}{\partial\alpha_{i}}\in\mathbb{R}^{k}$.

[TABLE]

where $\mathbf{G}_{t,j}\mathrel{\overset{\makebox[0.0pt]{\mbox{def}}}{=}}\frac{\partial\Delta_{t}(\mathbf{w}_{t}(\boldsymbol{\alpha}))}{\partial w_{t,j}}\in\mathbb{R}^{k}$, $\mathbf{G}_{t}\mathrel{\overset{\makebox[0.0pt]{\mbox{def}}}{=}}[\mathbf{G}_{t,1},\ldots,\mathbf{G}_{t,k}]\in\mathbb{R}^{k\times k}$, and  Therefore, $\boldsymbol{\psi}_{t+1,i}$ represents a sum of updates, with a recursive weighting on previous $\boldsymbol{\psi}_{t,i}$ adjusting the weight of previous updates in the sum.

We can approximate the gradient using this recursive relationship, without storing all previous samples. Though the above updates are exact, we obtain an approximation when implementing such a recursive form in practice. When using $\boldsymbol{\psi}_{t-1,i}$ computed on the last time step $t-1$, this gradient estimate is in fact w.r.t. the previous step-size $\boldsymbol{\alpha}_{t-2}$, rather than $\boldsymbol{\alpha}_{t-1}$. Because these step-sizes are slowly changing, this gradient still provides a reasonable estimate; however, for many steps into the past, the accumulated gradients in $\boldsymbol{\psi}_{t,i}$ are likely inaccurate. To improve the approximation, and forget old gradients, we introduce a forgetting parameter $0<\beta<1$, which focuses the accumulation of gradients in $\boldsymbol{\psi}_{t,i}$ to a more recent window.

The gradient update to the step-size also needs to ensure that the step-sizes remain positive. Similarly to IDBD, we use an exponential form for the step-size, where $\alpha=\exp(\beta)$ and $\beta\in\mathbb{R}$ is updated with (unconstrained) stochastic gradient descent. Conveniently, as we show in the appendix, we do not need to maintain this auxiliary variable, and can simply directly update $\boldsymbol{\alpha}$.

The resulting generic updates for quadratic-complexity AdaGain, with meta step-size $\bar{\alpha}$, are

[TABLE]

where the exponential is applied element-wise, $\boldsymbol{\psi}_{0,i}=\mathbf{0}$, $\boldsymbol{\alpha}_{0}=0.1$ (or some initial value), and $(\boldsymbol{\Psi}_{t})_{:,i}=\boldsymbol{\psi}_{t,i}\text{ with }\boldsymbol{\Psi}_{t}\in\mathbb{R}^{k\times k}$. For computational efficiency to avoid matrix-matrix multiplication, the order of multiplication for $\boldsymbol{\Psi}_{t}^{\top}\mathbf{G}_{t}^{\top}\Delta_{t}$ should start from the right, as $\boldsymbol{\Psi}_{t}^{\top}(\mathbf{G}_{t}^{\top}\Delta_{t})$. The key complexity in deriving an AdaGain update, then, is simply in computing the Jacobian $\mathbf{G}_{t}$; given this, the remainder of the algorithm is fixed. For each update $\Delta_{t}(\mathbf{w}_{t}(\boldsymbol{\alpha}))$, the Jacobian will be different, but is straightforward to compute.

Generic AdaGain algorithm with linear-complexity

Maintaining the entire matrix $\boldsymbol{\Psi}_{t}$ can be prohibitively expensive. As was done in IDBD (?), one way to avoid maintaining this matrix is to assume that $\frac{\partial w_{t,j}}{\partial\alpha_{i}}=0$ for $i\neq j$. This heuristic reflects that $\alpha_{i}$ is likely to have the largest impact on $w_{t,i}$, and less impact on the other entries in $\mathbf{w}_{t}$.

The modification above for this heuristic is straightforward, simply by setting entries $(\boldsymbol{\psi}_{t,i})_{j}=0$ for $i\neq j$. This results in the simplification

[TABLE]

Further, since we will then assume that $(\boldsymbol{\psi}_{t+1,i})_{j}=0$ for $i\neq j$, there is no purpose in computing the full vector $\mathbf{G}_{t,i}(\boldsymbol{\psi}_{t,i})_{i}$. Instead, we only need to compute the $i$th entry, i.e., for $\frac{\partial\Delta_{t,i}(\boldsymbol{\alpha})}{\partial w_{t,i}}$. We can then instead define $\hat{\psi}_{t,i}$ to be a scalar approximating $\frac{\partial w_{t,i}}{\partial\alpha_{i}}$, with $\hat{\boldsymbol{\psi}}_{t}$ the vector of these, and $\hat{\mathbf{j}}_{t}\mathrel{\overset{\makebox[0.0pt]{\mbox{def}}}{=}}\left[\frac{\partial\Delta_{t,1}(\boldsymbol{\alpha})}{\partial\mathbf{w}_{t,1}},\ldots,\frac{\partial\Delta_{t,k}(\boldsymbol{\alpha})}{\partial\mathbf{w}_{t,k}}\right]$ to define the recursion as $\hat{\boldsymbol{\psi}}_{t+1}\mathrel{\overset{\makebox[0.0pt]{\mbox{def}}}{=}}\hat{\boldsymbol{\psi}}_{t}+\boldsymbol{\alpha}\circ\hat{\mathbf{j}}_{t}\circ\hat{\boldsymbol{\psi}}_{t}+\Delta_{t}(\mathbf{w}_{t}(\boldsymbol{\alpha}))$, with $\hat{\boldsymbol{\psi}}_{0}=\mathbf{0}$. The gradient using this approximation, with off-diagonals zero, is

[TABLE]

To compute this approximation, for all $i$, we still need to be able to compute $\mathbf{G}_{t}^{\top}\Delta_{t}(\mathbf{w}_{t}(\boldsymbol{\alpha}))$. In some cases this is straightforward, as is the case for linear TD (found in the appendix). More generally, we can use R-operators (?) to compute this Jacobian-vector product, or a simple finite difference approximation, as we do in the appendix. Therefore, because we can compute this Jacobian-vector product in linear time, the only approximation is to $\hat{\boldsymbol{\psi}}_{t}$. The update is

[TABLE]

These approximations parallel diagonal approximations, for second-order techniques, which similarly assume off-diagonal elements are zero. Further, $\mathbf{G}_{t}$ itself is a gradient of the update w.r.t. the weights, where this update was already likely the gradient of the loss w.r.t. the weights. This $\mathbf{G}_{t}$, therefore, contains similar information as the Hessian. The AdaGain update, therefore, contains some information about curvature, but allows for updates that are not necessarily (true) gradient updates.

This AdaGain update is generic, but does require computing the Jacobian of a given update, which could be onerous in certain settings. We provide an update, based on finite differences in the appendix, that only requires differences between updates, that we have found works well in practice.

Experiments in synthetic tasks

We conduct experiments in several simulation domains to highlight the performance characteristics of meta-descent and quasi-second order methods. In our first experiment we investigate AdaGain and several meta-descent and quasi-second order approaches on a notoriously difficult stationary optimization task. Next we return to the simple state-less tracking problem described in the introduction, and investigate the parameter sensitivity of each method. Our third experiment investigates how different optimization algorithms can stabilize the iterates in sequential off-policy learning problems, which cause SGD-based methods to diverge. We conclude with a comparison of AdaGain and AMSGrad (the best performing quasi-second order method in the first three experiments) for online prediction on data generated by a mobile robot.

In all the experiments, we use AdaGain layered on-top of an RMSProp update, rather than a vanilla SGD update. As motivated earlier, meta-descent methods are not robust on difficult optimization surfaces, such as with flat or sharp regions. AdaGain provides a practical method to pursue meta-descent strategies that are robust to such realistic optimization problems. We motivate the importance of this choice in our first experiment on a difficult optimization task.

Function optimization. The aim of our first experiment is to investigate how AdaGain performs on optimization problems designed to be difficult for gradient descent. The Rosenbrock function is a two dimensional non-convex function, and the minimum is inside a flat parabolic shaped valley. We compared AMSGrad, SGD, and SMD, in each case extensively searching the meta-parameters of each method, averaging performance over 100 runs and 6000 optimization steps. The results are summarized in Figure 2, with trajectory plots of a single run of each algorithm, and the learning curves for all methods. AdaGain both learns faster and gets closer to the global optimum than all other methods considered. Further, two meta-descent methods, SMD and AdaGain without RMSProp perform poorly. This result highlights issues with applying meta-descent approaches without considering the optimization surface, and the importance of having an algorithm like AdaGain which can be combined with quasi-second order methods.

Stateless tracking problem. Recall from Figure 1, that several methods performed well in the stateless tracking problem; sensitivity to parameter settings, however, is also important. To help better understand these methods, we constructed a parameter sensitivity graph (Figure 3). IDBD can outperform AdaGain on this problem (lower MSE), but only a tiny fraction of IDBD’s parameter settings achieve good performance. None of AdaGrad’s parameter combinations exceeded the threshold, but all combinations resulted in high error compared with AdaGain. Many of the parameter combinations allowed AdaGain to achieve low error, suggesting AdaGain with a simple manual parameter tuning is likely to achieve good performance on this problem, while IDBD likely requires a comprehensive parameter sweep.

Baird’s counterexample. Our final synthetic-domain experiment tests the stability of AdaGain’s update when combined with the TD($\lambda$) algorithm for off-policy state-value prediction in a Markov Decision Process. We use Baird’s counterexample, which causes the weight’s learned by off-policy TD($\lambda$) (?) to diverge if a global step-size parameter is used (decaying or otherwise) (?; ?; ?). The key challenge is the feature representation, and the difference between the target and behavior policies. There is a shared redundant feature, and the weight associated seventh feature is initialized to a high value. The target policy always chooses to go to state seven and stay there forever. The behavior policy, on the other hand, only visits state seven 1/7 the time, causing large importance sampling corrections.

We applied AdaGain, Adam, RMSprop, SMD, and TIDBD(?)—a recent extension of the IDBD algorithm — to adapt the step-sizes of linear TD($\lambda$) on Baird’s counterexample. As before, the meta-parameters were extensively swept and the best performing parameters were used to generate the results for comparison. Figure 5 shows the learning curves of each method. Only AdaGain and Adam are able to prevent divergence. SMD’s performance is typical of Baird’s counterexample: the meta-parameter search simply found parameters that caused extremely slow divergence. AdaGain learns significantly faster than Adam, and achieves lower error.

To understand how AdaGain prevents divergence consider Figure 4. The left graph shows the step-size values as they evolve over time, and the right graph shows the corresponding weights. Recall, the weight for feature seven is initialized to a high value. AdaGain initially increases feature seven’s step-size causing weight seven to quickly fall. In parallel AdaGain reduces the step-size for the redundant feature, preventing incorrect generalization. Over time the weights converge to one of many valid solutions, and the value error, plotted in black on the right side converges to zero. The left plots of Figure 5 show the same evolution of the weights and step-sizes for Adam. Adam is successful in reducing the step-size for the redundant feature, however the step-sizes of the other features decay quickly and then begin growing again preventing convergence to low value error.

Experiments on robot data

In our final experiment we recreate nexting (?), using TD($\lambda$) to make dozens of predictions about the future values of robot sensor readings. We formulate each prediction as estimating the discounted sum of future sensor readings, treating each sensor as a reward signal with discount factor of $\gamma=0.9875$ corresponding to approximately 80 second predictions. Using the freely available nexting data set (144,000 samples, corresponding to 3.4 hours of runtime on the robot), we incrementally processed the data on each step constructing a feature vector from the sensor vector, and making one prediction for each sensor. At the end of learning we computed the ”ideal” prediction offline and computed the symmetric mean absolute percentage error of each prediction, and aggregated the 50 learning curves using the median. We used the same non-linear coarse recoding of the sensor inputs described in the original work, giving 6065 binary feature components for use as a linear representation.

For this experiment we reduced the number of algorithms, using AMSGrad as the best performing quasi-second order method based on our synthetic task experiments and AdaGain as the representative meta-descent algorithm. The meta step-size was optimized for both algorithms.

The learning curves in Figure 6 show a clear advantage for AdaGain in terms of aggregate error over all predictions. Inspecting the predictions of one of the heat sensors reveals why. In early learning, AdaGain much more quickly increases the prediction, to near the ideal prediction, whereas AMSGrad much more slowly reaches this point—over 12000 steps. AdaGain and AMSGrad then both track the the ideal heat prediction similarly, and so obtain similar error for the remainder of learning. This advantage in initial learning is also demonstrated in Figure 7, which depicts predictions on two different sensors. For example, AdaGain adapts the predictions more quickly in reaction to the unexpected stall event, but otherwise AdaGain and AMSGrad obtain similar errors. This result also serves as a sanity check for AdaGain, validating that AdaGain does scale to more realistic problems and remains stable in the face of high levels of noise and high-magnitude prediction targets.

Conclusion

In this work, we proposed a new general meta-descent strategy, to adapt a vector of stepsizes for online, continual prediction problems. We defined a new meta-descent objective, that enables a broader class of incremental updates for the base learner, generalizing beyond work specialized to least-mean squares, temporal difference learning and vanilla stochastic gradient descent updates. We derive a recursive update for the stepsizes, and provide a linear-complexity approximation. In a series of experiments, we highlight that meta-descent strategies are not robust to the shape of the optimization surface. The ability to use AdaGain for generic updates enabled us to overcome this issue, by layering AdaGain on RMSProp, a simple quasi-second order approach. We then showed that, with this modification, meta-descent methods can perform better than the more commonly used quasi-second order updates, adapting more quickly in non-stationary tasks.

Appendix A Stochastic Meta-Descent algorithm

We recreate the SMD derivation, in our notation, for easier reference.

We compute the gradient of the loss function $\ell(\mathbf{w})$, w.r.t. stepsize. We derive the full quadratic-complexity algorithm to start, and then introduce approximations to obtain a linear-complexity algorithm. For stepsize $\alpha_{i}$ as the $i$th element in the vector $\boldsymbol{\alpha}$,

[TABLE]

Define the following two vectors, for $w_{t,j}$ the $j$-th element in vector $w_{t,j}$,

[TABLE]

We can obtain vector $\boldsymbol{\psi}_{t,i}$ recursively as

[TABLE]

The resulting generic updates for quadratic-complexity SMD, with meta stepsize $\bar{\alpha}$, are

[TABLE]

$\boldsymbol{\psi}_{0,i}=\mathbf{0}$ and $\boldsymbol{\alpha}_{0}=0.1$ (or some initial value). As with AdaGain, the Hessian-vector product $\mathbf{H}_{t}\boldsymbol{\psi}_{t,i}$ can be computed efficiently, using R-operators. Here, it is irrelevant, because we maintain the quadratic $\boldsymbol{\Psi}$.

For the linear-complexity algorithm, again we set entries $(\boldsymbol{\psi}_{t,i})_{j}=0$ for $i\neq j$. Let $\mathbf{H}_{t,i}$ be the $i$th column of the Hessian. This results in the simplification

[TABLE]

Further, since we will then assume that $(\boldsymbol{\psi}_{t+1,i})_{j}=0$ for $i\neq j$, there is no purpose in computing the full vector $\mathbf{H}_{t,i}(\boldsymbol{\psi}_{t,i})_{i}$. Instead, we only need to compute the $i$th entry, i.e., for $\frac{\partial\mathbf{g}_{t,i}(\boldsymbol{\alpha})}{\partial w_{t,i}}$. We can then instead define $\hat{\psi}_{t,i}$ to be a scalar approximating $\frac{\partial w_{t,i}}{\partial\alpha_{i}}$, with $\hat{\boldsymbol{\psi}}_{t}$ the vector of these, and the diagonal of the Hessian

[TABLE]

to define the recursion as $\hat{\boldsymbol{\psi}}_{t+1}\mathrel{\overset{\makebox[0.0pt]{\mbox{def}}}{=}}\hat{\boldsymbol{\psi}}_{t}-\boldsymbol{\alpha}\circ\hat{\mathbf{h}}_{t}\circ\hat{\boldsymbol{\psi}}_{t}+\mathbf{g}_{t}(\boldsymbol{\alpha})$, with $\hat{\boldsymbol{\psi}}_{0}=\mathbf{0}$. The gradient using this approximation, with off-diagonals zero, is

[TABLE]

The resulting update to the stepsize is

[TABLE]

Difference to original SMD algorithm: Now, surprisingly, the above algorithm differs from the algorithm given for SMD. But, that derivation appears to have a flaw, where the gradients of weights taken w.r.t. to a vector of stepsizes is assumed to be a vector. Rather, with the same off-diagonal approximation we use, it should be a diagonal matrix, and then they would also only get a diagonal Hessian. For completeness, we include their algorithm, which uses a full Hessian-vector product.

[TABLE]

Note that a follow-up paper that tested SMD (?) uses this update, but does not have an error, because they use a scalar step size. In fact, in the SMD paper, if the step size had been a scalar, then their derivation would be correct.

The addition of $\beta$: The original SMD algorithm did not use forgetting with $\beta$. In our experiments, however, we consider SMD with $\beta$—which performs significantly better—since our goal is not to compare directly with SMD, but rather to compare the choice of objectives.

Appendix B Derivations for AdaGain updates

Consider again the generic update

[TABLE]

where $\Delta_{t}\in\mathbb{R}^{d}$ is the update for this step, for weights $\mathbf{w}_{t}\in\mathbb{R}^{d}$ and constant vector stepsize $\boldsymbol{\alpha}$ and the operator $\circ$ denotes element-wise multiplication.

Maintaining non-negative stepsizes in AdaGain

One straightforward option to maintain non-negative stepsizes is to define a constraint on the stepsize. We can prevent the stepsize from going below a small threshold $\epsilon$ (e.g., $\epsilon=0.001$), ensuring positive stepsizes. The projection onto this constraint set after each gradient descent step simply involves applying the operator $(\cdot)_{\epsilon}$, which thresholds any values below $\epsilon>0$ to $\epsilon$. We experimented with this strategy compared to the mentioned exponential form, and found it performed relatively similarly, but required an extra parameter to tune.

Another option—and the one we use in this work—is to use an exponential form for the stepsize, so that it remains positive. One form, used also by IDBD, is to use $\boldsymbol{\alpha}=\exp(\boldsymbol{\beta})$. The algorithm, with or without an exponential form, remains essentially identical to the thresholded version, because

[TABLE]

Therefore, we can still recursively estimate the gradient with the same approach, regardless of how the stepsize $\boldsymbol{\alpha}$ is constrained. For the thresholded form, we simply use the gradient $\Delta_{t}(\boldsymbol{\alpha}(\boldsymbol{\beta}))\frac{\Delta_{t}(\boldsymbol{\alpha})}{\partial\alpha_{i}}$ and then project (i.e., threshold). For the exponential form, the gradient update for $\boldsymbol{\alpha}$ is simply used within an exponential function, as described below.

Consider directly maintaining $\boldsymbol{\beta}$, which is unconstrained. For the function form $\alpha_{i}=\exp(\beta_{i})$, the partial derivative $\frac{\partial\alpha_{i}}{\partial\beta_{i}}$ is simply equal to $\alpha_{i}$ and so the gradient update includes an additional $\alpha_{i}$ in front. This can more explicitly be maintained, without an additional variable, by noticing that for gradient $g_{i}=\alpha_{i}\Delta_{t}(\boldsymbol{\alpha}(\boldsymbol{\beta}))\frac{\Delta_{t}(\boldsymbol{\alpha}(\boldsymbol{\beta}))}{\partial\alpha_{i}}$ for $\beta_{t,i}$

[TABLE]

Therefore, we can still directly maintain $\boldsymbol{\alpha}$. The resulting update to $\boldsymbol{\alpha}$ is simply

[TABLE]

Other multiplicative updates are also possible. ?  (?) uses an exponential update, but uses an approximation with a maximum, to avoid the expensive computation of the exponential function. ?  (?) uses a similar multiplicative update, but without a maximum.

AdaGain for linear TD

In this section, we derive $\mathbf{g}_{t}$ for a particular algorithm, namely linear TD. LMS updates can be obtained as special cases, by setting $\gamma=0$. We then provide a more general update algorithm—which does not require knowledge of the form of the update—in the next section. One advantage of AdaGain is that it is derived generically, allowing extensions to many online algorithms, unlike IDBD, and variants which are derived specifically for the squared TD-error.

We first provide the AdaGain updates for linear TD($\lambda$), and then provide the derivation below. For TD($\lambda$), the update is

[TABLE]

where $\boldsymbol{\alpha}_{0}=0.1$, $\hat{\boldsymbol{\psi}}_{0}=\mathbf{0}$, $\gamma_{t}\mathrel{\overset{\makebox[0.0pt]{\mbox{def}}}{=}}\gamma(S_{t},A_{t},S_{t+1})$

To derive the update for $\boldsymbol{\alpha}$, we need to compute the gradients of the updates, particularly $(\mathbf{g}_{t})_{i}=\frac{\partial\Delta_{t,i}}{\partial\mathbf{w}_{t,i}}$ or for the full algorithm, the Jacobian $\mathbf{G}$.

[TABLE]

Letting $\mathbf{d}_{t}\mathrel{\overset{\makebox[0.0pt]{\mbox{def}}}{=}}\gamma_{t+1}\mathbf{x}_{t+1}-\mathbf{x}_{t}$, the Jacobian is $\mathbf{G}_{t}=\mathbf{e}_{t}\mathbf{d}_{t}^{\top}$ and the diagonal approximation is $\mathbf{g}_{t}=\mathbf{e}_{t}\circ\mathbf{d}_{t}$. Because of the form of the Jacobian, we can actually use it in the update to $\boldsymbol{\alpha}$, though not in computing $\hat{\boldsymbol{\psi}}_{t}$, if we want to maintain linearity. The quadratic complexity algorithm uses $\mathbf{G}$ as given

[TABLE]

The linear complexity algorithm uses $\mathbf{g}_{t}$ to update $\hat{\boldsymbol{\psi}}_{t}$, giving the stepsize update in (23)

[TABLE]

Generic AdaGain algorithm

To avoid requiring knowledge about the algorithm update and its derivatives, we can provide an approximation to the Jacobian-vector product and the diagonal of the Jacobian, using finite differences. As long as the update function for the algorithm can be queried multiple times, this algorithm can be easily applied to any update.

To compute the Jacobian-vector product, we use the fact that this corresponds to a directional derivative. Notice that $\mathbf{G}_{t}^{\top}\Delta_{t}$ corresponds to the vector of directional derivatives for each component (function) in the update $\Delta_{t}$, in the direction of $\mathbf{u}=\Delta_{t}$, because the dot-product separates in $\mathbf{G}_{t,1}^{\top}\mathbf{u},\ldots,\mathbf{G}_{t,k}^{\top}\mathbf{u}$. Therefore, for update function $\Delta:\mathbb{R}^{k}\rightarrow\mathbb{R}^{k}$ (such as the gradient of the loss), we get for small $r=0.001$,

[TABLE]

For the diagonal of the Jacobian, we can again use finite differences. An efficient finite difference computation is proposed within the simultaneous perturbation stochastic approximation algorithm (?), which uses a random perturbation vector $\boldsymbol{\epsilon}$ to compute the centered difference $\frac{(\Delta(\mathbf{w}+r\boldsymbol{\epsilon})-\Delta(\mathbf{w}-r\boldsymbol{\epsilon}))_{i}}{2r\boldsymbol{\epsilon}_{i}}$. This formula provides an approximation to the gradient of the $i$ entry in the update $\Delta_{t}$ with respect to weight $i$; when computed for all $i$, this approximates the diagonal of the Jacobian $\hat{\mathbf{j}}_{t}$. To avoid additional computation, we can re-use the above difference with perturbation $\mathbf{u}$, rather than a random vector $\boldsymbol{\epsilon}$. To avoid division by zero, if $\mathbf{u}$ contains a zero entry, we threshold the normalization with a small constant $10^{-6}$ to give

[TABLE]

where division is element-wise. another approach would be to sample a random direction $\boldsymbol{\epsilon}$ for this finite difference and use $\Delta(\mathbf{w}+\boldsymbol{\epsilon})-\Delta(\mathbf{w})$, divided by the absolute value of each element of $\boldsymbol{\epsilon}$. We found empirically that using the same direction as $\Delta_{t}$ was actually more effective, and more computationally efficient, so we propose that approach.

Using these approximations, we can compute the update to the stepsize as in Equation (10), repeated here for easy reference

[TABLE]