The goal of reinforcement learning algorithms is to estimate and/or optimise the value function. However, unlike supervised learning, no teacher or oracle is available to provide the true value function. Instead, the majority of reinforcement learning algorithms estimate and/or optimise a proxy for the value function. This proxy is typically based on a sampled and bootstrapped approximation to the true value function, known as a return. The particular choice of return is one of the chief components determining the nature of the algorithm: the rate at which future rewards are discounted; when and how values should be bootstrapped; or even the nature of the rewards themselves. It is well-known that these decisions are crucial to the overall success of RL algorithms. We discuss a gradient-based meta-learning algorithm that is able to adapt the nature of the return, online, whilst interacting and learning from the environment. When applied to 57 games on the Atari 2600 environment over 200 million frames, our algorithm achieved a new state-of-the-art performance. The central goal of reinforcement learning (RL) is to optimise the agent's return (cumulative reward); this is typically achieved by a combination of prediction and control. The prediction subtask is to estimate the value function -the expected return from any given state. Ideally, this would be achieved by updating an approximate value function towards the true value function. The control subtask is to optimise the agent's policy for selecting actions, so as to maximise the value function. Ideally, the policy would simply be updated in the direction that increases the true value function. However, the true value function is unknown and therefore, for both prediction and control, a sampled return is instead used as a proxy. A large family of RL algorithms [Sutton, 1988 , Rummery and Niranjan, 1994 , van Seijen et al., 2009 , Sutton and Barto, 2018 , including several state-of-the-art deep RL algorithms [Mnih et al., 2015 , van Hasselt et al., 2016 , Harutyunyan et al., 2016, Hessel et al., 2018, Espeholt et al., 2018, are characterised by different choices of the return. The discount factor γ determines the time-scale of the return. A discount factor close to γ = 1 provides a long-sighted goal that accumulates rewards far into the future, while a discount factor close to γ = 0 provides a short-sighted goal that prioritises short-term rewards. Even in problems where long-sightedness is clearly desired, it is frequently observed that discounts γ < 1 achieve better results [Prokhorov and Wunsch, 1997], especially during early learning. It is known that many algorithms converge faster with lower discounts [Bertsekas and Tsitsiklis, 1996], but of course too low a discount can lead to highly sub-optimal policies that are too myopic. In practice it can be better to first optimise for a myopic horizon, e.g., with γ = 0 at first, and then to repeatedly increase the discount only after learning is somewhat successful [Prokhorov and Wunsch, 1997]. The return may also be bootstrapped at different time horizons. An n-step return accumulates rewards over n time-steps and then adds the value function at the nth time-step. The λ-return [Sutton, 1988, Sutton and Barto, 2018 ] is a geometrically weighted combination of n-step returns. In either case, the meta-parameter n or λ can be important to the performance of the algorithm, trading off bias and variance. Many researchers have sought to automate the selection of these parameters [Kearns and Singh, 2000, Downey and Sanner, 2010, Konidaris et al., 2011. Preprint. Work in progress. There are potentially many other design choices that may be represented in the return, including off-policy corrections [Espeholt et al., 2018, Munos et al., 2016, target networks [Mnih et al., 2015], emphasis on certain states [Sutton et al., 2016] , reward clipping [Mnih et al., 2013], or even the nature of the rewards themselves [Randløv and Alstrøm, 1998 , Singh et al., 2005 , Zheng et al., 2018 . In this work, we are interested in one of the fundamental problems in reinforcement learning: what would be the best form of return for the agent to maximise? Specifically, we propose to learn the return function by treating it as a parametric function with tunable meta-parameters η, for instance including the discount factor γ, or the bootstrapping parameter λ [Sutton, 1988] . The meta-parameters η are adjusted online during the agent's interaction with the environment, allowing the return to both adapt to the specific problem, and also to dynamically adapt over time to the changing context of learning. We derive a practical gradient-based meta-learning algorithm and show that this can significantly improve performance on large-scale deep reinforcement learning applications. In deep reinforcement learning, the value function and policy are approximated by a neural network with parameters θ, denoted by v θ (S) and π θ (A|S) respectively. At the core of the algorithm is an update function, that adjusts parameters from a sequence of experience τ t = {S t , A t , R t+1 , . . .} consisting of states S, actions A and rewards R. The nature of the function is determined by meta-parameters η. Our meta-gradient RL approach is based on the principle of online cross-validation [Sutton, 1992] , using successive samples of experience. The underlying RL algorithm is applied to the first sample (or samples), and its performance is measured in a subsequent sample. Specifically, the algorithm starts with parameters θ, and applies the update function to the first sample(s), resulting in new parameters θ ; the gradient dθ /dη of these updates indicates how the meta-parameters affected these new parameters. The algorithm then measures the performance of the new parameters θ on a subsequent, independent sample τ , utilising a differentiable meta-objective J (τ , θ , η ). When validating the performance on the second sample, we use a fixed meta-parameter η in J as a reference value. In this way, we form a differentiable function of the meta-parameters, and obtain the gradient of η by taking the derivative of meta-objective J w.r.t. η and applying the chain rule: To compute the gradient of the updates, dθ /dη, we note that the parameters form an additive sequence, and the gradient can therefore be accumulated online, The gradient ∂f (τ, θ, η)/∂θ is large and challenging to compute in practice. Instead we approximate the gradient using an accumulative trace z ≈ dθ/dη, The gradient in Equation (3) is defined for fixed meta-parameters η. In practice, the meta-parameters will adapt online. To allow for this adaptation, the parameter µ ∈ [0, 1] decays the trace and focuses on recent updates. Choosing µ = 0 results in a greedy meta-gradient that considers only the immediate effect of the meta-parameters η on the parameters θ; this may often be sufficient. Finally, the meta-parameters η are updated to optimise the meta-objective, for example by applying stochastic gradient descent (SGD) to update η in the direction of the meta-gradient, where β is the learning rate for updating meta parameter η. In the following sections we instantiate this idea more specifically to RL algorithms based on predicting or controlling returns. We begin with a pedagogical example of using meta-gradients for 2 prediction using a temporal-difference update. We then consider meta-gradients for control, using a canonical actor-critic update function and a policy gradient meta-objective. Many other instantiations of meta-gradient RL would be possible, since the majority of deep reinforcement learning updates are differentiable functions of the return, including, for instance, value-based methods like SARSA(λ) [Rummery and Niranjan, 1994, Sutton and Barto, 2018] and DQN [Mnih et al., 2015], policygradient methods [Williams, 1992] , or actor-critic algorithms like A3C [Mnih et al., 2016] and IMPALA [Espeholt et al., 2018]. We define the return g η (τ t ) to be a function of an episode or a truncated n-step sequence of experience τ t = {S t , A t , R t+1 , . . . , S t+n }. The nature of the return is determined by the meta-parameters η. The n-step return [Sutton and Barto, 2018] accumulates rewards over the sequence and then bootstraps from the value function, where η = {γ, n}. The λ-return is a geometric mixture of n-step returns, [Sutton, 1988]  where η = {γ, λ}. The λ-return has the advantage of being fully differentiable with respect to the meta-parameters. The meta-parameters η may be viewed as gates that cause the return to terminate (γ = 0) or bootstrap (λ = 0), or to continue onto the next step (γ = 1 and λ = 1). The n-step or λ-return can be augmented with off-policy corrections [Precup et al., 2000 , Sutton et al., 2014 , Espeholt et al., 2018 if it is necessary to correct for the distribution used to generate the data. A typical RL algorithm would hand-select the meta-parameters, such as the discount factor γ and bootstrapping parameter λ, and these would be held fixed throughout training. Instead, we view the return g as a function parameterised by meta-parameters η, which may be differentiated to understand its dependence on η. This in turn allows us to compute the gradient ∂f /∂η of the update function with respect to the meta-parameters η, and hence the meta-gradient ∂J (τ , θ , η )/∂η. In essence, our agent asks itself the question, "which return results in the best performance?", and adjusts its meta-parameters accordingly. We begin with a simple instantiation of the idea, based on the canonical TD(λ) algorithm for prediction. The objective of the TD(λ) algorithm (according to the forward view [Sutton and Barto, 2018] ) is to minimise the squared error between the value function approximator v θ (S) and the λ-return g η (τ ), where τ is a sampled trajectory starting with state S, and ∂J(τ, θ, η)/∂θ is a semi-gradient [Sutton and Barto, 2018] , i.e. the λ-return is treated as constant with respect to θ. The TD(λ) update function f (·) applies SGD to update the agent's parameters θ to descend the gradient of the objective with respect to the parameters, where α is the learning rate for updating agent θ. We note that this update is itself a differentiable function of the meta-parameters η, The key idea of the meta-gradient prediction algorithm is to adjust meta-parameters η in the direction that achieves the best predictive accuracy. This is measured by cross-validating the new parameters θ 3 on a second trajectory τ that starts from state S , using a mean squared error (MSE) meta-objective and taking its semi-gradient, The meta-objective in this case could make use of an unbiased and long-sighted return 1 , for example using η = {γ , λ } where γ = 1 and λ = 1. We now provide a practical example of meta-gradients applied to control. We focus on the A2C algorithm -an actor-critic update function that combines both prediction and control into a single update. This update function is widely used in several state-of-the-art agents [Mnih et al., 2016, Jaderberg et al., 2017b, Espeholt et al., 2018. The semi-gradient of the A2C objective, ∂J(τ ; θ, η)/∂θ, is defined as follows, The first term represents a control objective, encouraging the policy π θ to select actions that maximise the return. The second term represents a prediction objective, encouraging the value function approximator v θ to more accurately estimate the return g η (τ ). The third term regularises the policy according to its entropy H(π θ ), and b, c are scalar coefficients that weight the different components in the objective function. The A2C update function f (·) applies SGD to update the agent's parameters θ. This update function is a differentiable function of the meta-parameters η, Now we come to the choice of meta-objective J to use for control. Our goal is to identify the return function that maximises overall performance in our agents. This may be directly measured by a meta-objective focused exclusively on optimising returns -in other words a policy gradient objective, This equation evaluates how good the updated policy θ is in terms of returns computed under η , when measured on "held-out" experiences τ , e.g. the subsequent n-step trajectory. When cross-validating performance using this meta-objective, we use fixed meta-parameters η , ideally representing a good proxy to the true objective of the agent. In practice this typically means selecting reasonable values of η ; the agent is free to adapt its meta-parameters η and choose values that perform better in practice. We now put the meta-gradient control algorithm together. First, the parameters θ are updated on a sample of experience τ using the A2C update function (Equation (12)), and the gradient of the update (Equation (13)) is accumulated into trace z. Second, the performance is cross-validated on a subsequent sample of experience τ using the policy gradient meta-objective (Equation (14)). Finally, the meta-parameters η are updated according to the gradient of the meta-objective (Equation (5)). One complication of the approach outlined above is that the return function g η (τ ) is non-stationary, adapting along with the meta-parameters throughout the training process. As a result, there is a danger that the value function v θ becomes inaccurate, since it may be approximating old returns. For example, the value function may initially form a good approximation of a short-sighted return with γ = 0, but if γ subsequently adapts to γ = 1 then the value function may suddenly find its approximation is rather poor. The same principle applies for the policy π, which again may have specialised to old returns. 1 The meta-objective could even use a discount factor that is longer-sighted than the original problem, perhaps spanning over many episodes. (a) Rewards alternate between +0.1 or randomly sampling from a zero-mean Gaussian. . In each of the subplot shown in the bottom, the first one shows how the meta-parameter γ or λ adapts over the course of training (averaged over 10 seeds -shaded regions cover 20%-80% percentiles). The second plot shows the final value of γ or λ in each state, identifying appropriately high/low values for odd/even states respectively (violin plots show distribution over seeds). To deal with non-stationarity in the value function and policy, we utilise an idea similar to universal value function approximation (UVFA) [Schaul et al., 2015]. The key idea is to provide the metaparameters η as an additional input to condition the value function and policy, as follows: where e η is the embedding of η, [s; e η ] denotes concatenation of vectors s and e η , W η is the embedding matrix (or row vector, for scalar η) that is updated by backpropagation during training. In this way, the agent explicitly learns value functions and policies that are appropriate for various η. The approximation problem becomes a little harder, but the payoff is that the algorithm can freely shift the meta-parameters without needing to wait for the approximator to "catch up". To scale up the meta-gradient approach, several additional steps were taken. For efficiency, the A2C objective and meta-objective were accumulated over all time-steps within an n-step trajectory of experience. The A2C objective was optimised by RMSProp [Tieleman and Hinton, 2012] without momentum [Mnih et al., 2015, Espeholt et al., 2018. This is a differentiable function of the meta-parameters, and can therefore be substituted similarly to SGD (see Equation (13)); this process may be simplified by automatic differentiation (Appendix B.2). As in IMPALA, an off-policy correction was used, based on a V-trace return (see Appendix B.1). For efficient implementation, mini-batches of trajectories were computed in parallel; trajectories were reused twice for both the update function and for cross-validation (see Appendix B.3). To illustrate the key idea of our meta-gradient approach, we provide two examples that show how the discount factor γ and temporal difference parameter λ, respectively, can be meta-learned. We focus on meta-gradient prediction using the TD(λ) algorithm and a MSE meta-objective with γ = 1 and λ = 1, as described in Section 1.2. For these illustrative examples, we consider state-dependent meta-parameters that can take on a different value in each state. The first example is a 10-step Markov reward process (MRP), that alternates between "signal" and "noise" transitions. Transitions from odd-numbered "signal" states receive a small positive reward, R = +0.1. Transitions from even-numbered "noise" states receive a random reward, R ∼ N (0, 1). To ensure that the signal can overwhelm the noise, it is beneficial to terminate the return (low γ) in "noise" states, but to continue the return (high γ) in "signal" states. The second example is a 9-step MRP, that alternates between "fan-out" and "fan-in" transitions. At odd-numbered "fan-out" time-steps, the state transitions to a randomly sampled successor, all of which are aliased. At even-numbered "fan-in" time-steps, the state deterministically transitions back to a bottleneck state. The transition to a "fan-out" state yields a deterministic reward unique to that state. The transition away from that state yields the negation of that same reward. Each pair of "fan-in" and "fan-out" time-steps is zero-mean in expected reward. The fully observed bottleneck states are visited frequently and tend to have more accurate value functions. To predict accurately, it is therefore beneficial to bootstrap (low λ) in bottleneck states for which the value function is well-known, but to avoid bootstrapping (high λ) in the noisier, partially observed, fanned-out states. Figure 1 shows the results of meta-gradient prediction using the TD(λ) algorithm. The meta-gradient algorithm was able to adapt both λ and γ to form returns that alternate between high or low values in odd or even states respectively. In this section, we demonstrate the advantages of the proposed meta-gradient learning approach using a state-of-the-art actor-critic framework IMPALA [Espeholt et al., 2018]. We focused on adapting the discount factor η = {γ} (which we found to be the most effective meta-parameter in preliminary experiments), and the bootstrapping parameter λ. For these experiments, the meta-parameters were state-independent, adapting one scalar value for γ and λ respectively (state-dependent metaparameters did not provide significant benefit in preliminary experiments).  We validate the proposed approach on Atari 2600 video games from Arcade Learning Environment (ALE) [Bellemare et al., 2013], a standard benchmark for deep reinforcement learning algorithms. We build our agent with the IMPALA framework [Espeholt et al., 2018], an efficient distributed implementation of actor-critic architecture Barto, 2018, Mnih et al., 2016]. We utilise the deep ResNet architecture [He et al., 2016] specified in Espeholt et al. [2018], which has shown great advantages over the shallow architecture [Mnih et al., 2015]. Following Espeholt et al., we train our agent for 200 million frames. Our algorithm does not require extra data compared to the baseline algorithms, as each experience can be utilised in both training the agent itself and training the meta parameters η (i.e., each experience can serve as validation data of other experiences). We describe the detailed implementation in the Appendix B.3. For full details about the IMPALA implementation and the specific off-policy correction g η (τ ), please refer to Espeholt et al. [2018]. The agents are evaluated on 57 different Atari games and the median of human-normalised scores [Nair et al., 2015 , van Hasselt et al., 2016 , Wang et al., 2016b , Mnih et al., 2016 are reported. There are two different evaluation protocols. The first protocol is is "human starts" [Nair et al., 2015 , Wang et al., 2016b , van Hasselt et al., 2016 , which initialises episodes to a state that is randomly sampled from human play. The second protocol is "no-ops starts", which initialises each episode with a random sequence of no-op actions; this protocol is also used during training. We keep all of the hyper-parameters (e.g., batch size, unroll length, learning rate, entropy cost) the same as specified in Espeholt et al. [2018] for a fair comparison. For self-contained purpose, we provide all of the important hyper-parameters used in this paper, including the ones following Espeholt et al. [2018] and the additional meta-learning optimisation hyper-parameters (i.e., meta batch size, meta learning rate α , embedding size for η), in Appendix A. The meta-learning hyper-parameters are chosen according to the performance of six Atari games as common practice in Deep RL Atari experiments [van Hasselt et al., 2016 , Mnih et al., 2016 , Wang et al., 2016b . Additional implementation details are provided in Appendix B. 2 In practice we parameterise η = σ(x), where σ is the logistic function σ(x) = 1 1+e −x ; i.e. the metaparameters are actually the logits of γ and λ. Table 1 : Results of meta-learning the discount parameter γ, the temporal-difference learning parameter λ, or both γ and λ, compared to the baseline IMPALA algorithm which meta-learns neither. Results are given both for the discount factor γ = 0.99 originally reported in [Espeholt et al., 2018] and also for a tuned discount factor γ = 0.995 (see Appendix C); the cross-validated discount factor γ in the meta-objective was set to the same value for a fair comparison. We compared four variants of the IMPALA algorithm: the original baseline algorithm without metagradients, i.e. η = {}; using meta-gradients with η = {λ}; using meta-gradients with η = {γ}; and using meta-gradients with η = {γ, λ}. The original IMPALA algorithm used a discount factor of γ = 0.99; however, when we manually tuned the discount factor and found that a discount factor of γ = 0.995 performed considerably better (see Appendix C). For a fair comparison, we tested our meta-gradient algorithm in both cases. When the discount factor is not adapted, η = {} or η = {λ}, we used a fixed value of γ = 0.99 or γ = 0.995. When the discount factor is adapted, η = {γ} or η = {γ, λ}, we cross-validate with a meta-parameter of γ = 0.99 or γ = 0.995 accordingly in the meta-objective J (Equation (14)). Manual tuning of the λ parameter did not have a significant impact on performance and we therefore compared only to the original value of λ = 1. We summarise the median human-normalised scores in Table 1 ; individual improvements on each game, compared to the IMPALA baseline, are given in Appendix D.1; and individual plots demonstrating the adaptation of γ and λ are provided in Appendix D.2. The meta-gradient RL algorithm increased the median performance, compared to the baseline algorithm, by a margin between 30% and 80% across "human starts" and "no-op starts" conditions, and with both γ = 0.99 and γ = 0.995. We also verified the architecture choice of conditioning the value function v and policy π on the metaparameters η. We compared the proposed algorithm with an identical meta-gradient algorithm that adapts the discount factor η = {γ}, but does not provide an embedding of the discount factor as an input to π and v. For this experiment, we used a cross-validation discount factor of γ = 0.995. The human-normalised median score was only 183%, well below the IMPALA baseline with γ = 0.995 (211.9%), and much worse than the full meta-gradient algorithm that includes the discount factor embedding (267.9%). Finally, we compare against the state-of-the-art agent trained on Atari games, namely Rainbow [Hessel et al., 2018], which combines DQN [Mnih et al., 2015] with double Q-learning [van Hasselt et al., 2016 , van Hasselt, 2010 , prioritised replay [Schaul et al., 2016], dueling networks [Wang et al., 2016b] , multi-step targets [Sutton, 1988, Sutton and Barto, 2018] , distributional RL [Bellemare et al., 2017], and parameter noise for exploration [Fortunato et al., 2018]. Rainbow obtains median human-normalised score of 153% on the human starts protocol and 223% on the no-ops protocol. In contrast, the meta-gradient agent achieved a median score of 292.9% on human starts and 287.6% on no-ops, with the same number (200M) of frames. We note, however, that there are many differences between the two algorithms, including the deeper neural network architecture used in our work. Among the earliest studies on meta learning (or learning to learn [Thrun and Pratt, 1998] been to meta-learn an optimiser using a recurrent parameterisation [Andrychowicz et al., 2016 , Wichrowska et al., 2017 . Duan et al. [2016] and Wang et al. [2016a] proposed to learn a recurrent meta-policy that itself learns to solve the reinforcement learning problem, so that the recurrent policy can generalise into new tasks faster than learning the policy from scratch. Model-Agnostic Meta-Learning (MAML) [Finn et al., 2017a, Finn and Levine, 2018, Finn et al., 2017b, Grant et al., 2018, Al-Shedivat et al., 2018] learns a good initialisation of the model that can adapt quickly to other tasks within a few gradient update steps. These works focus on a multi-task setting in which meta-learning takes place on a distribution of training tasks, to facilitate fast adaptation on an unseen test task. In contrast, our work emphasises the (arguably) more fundamental problem of meta-learning within a single task. In other words we return to the standard formulation of RL as maximising rewards during a single lifetime of interactions with an environment. Contemporaneously with our own work, Zheng et al. [2018] also propose a similar algorithm to learn meta-parameters of the return: in their case an auxiliary reward function that is added to the external rewards. They do not condition their value function or policy, and reuse the same samples for both the update function and the cross-validation step -which may be problematic in stochastic domains when the noise these updates becomes highly correlated. There are many works focusing on adapting learning rate through gradient-based methods [Sutton, 1992 , Schraudolph, 1999, Maclaurin et al., 2015, Pedregosa, 2016, Franceschi et al., 2017, Bayesian optimisation methods [Snoek et al., 2012] , or evolution based hyper-parameter tuning [Jaderberg et al., 2017a, Elfwing et al., 2017. In particular, Sutton [1992], introduced the idea of online crossvalidation; however, this method was limited in scope to adapting the learning rate for linear updates in supervised learning (later extended to non-linear updates by Schraudolph [1999]); whereas we focus on the fundamental problem of reinforcement learning, i.e., adapting the return function to maximise the proxy returns we can achieve from the environment. There has also been significant prior work on automatically adapting the bootstrapping parameter λ. TD(γ), that weights the n-step returns according to the discount factor, leading to a parameter-free algorithm for temporal-difference learning with linear function approximation. White and White [2016] introduce an algorithm that explicitly estimates the bias and variance, and greedily adapts λ to locally minimise the MSE of the λ-return. Unlike our meta-gradient approach, these prior approaches exploit i.i.d. assumptions on the trajectory of experience that are not realistic in many applications. In this work, we discussed how to learn the meta-parameters of a return function. Our meta-learning algorithm runs online, while interacting with a single environment, and successfully adapts the return to produce better performance. We demonstrated, by adjusting the meta-parameters of a state-ofthe-art deep learning algorithm, that we could achieve much higher performance than previously observed on 57 Atari 2600 games from the Arcade Learning Environment. Our proposed method is more general, and can be applied not just to the discount factor or bootstrapping parameter, but also to other components of the return, and even more generally to the learning update itself. Hyper-parameter tuning has been a thorn in the side of reinforcement learning research for several decades. Our hope is that this approach will allow agents to automatically tune their own hyper-parameters, by exposing them as meta-parameters of the learning update. This may also result in better performance because the parameters can change over time and adapt to novel environments.
REF proposed a meta-learner, which could learn to turn hyper-parameters of return function, to learn directly by meta learning to maximize the accumulate reward during a single lifetime of interactions with task environment.
Meta-Gradient Reinforcement Learning
ArXiv
ArXiv
Computer Science Mathematics