Title: LEARNING TO MIX n-STEP RETURNS: GENERALIZING λ-RETURNS FOR DEEP REINFORCEMENT LEARNING

Abstract: Reinforcement Learning (RL) can model complex behavior policies for goaldirected sequential decision making tasks. A hallmark of RL algorithms is Temporal Difference (TD) learning: value function for the current state is moved towards a bootstrapped target that is estimated using the next state's value function. λ-returns define the target of the RL agent as a weighted combination of rewards estimated by using multiple many-step look-aheads. Although mathematically tractable, the use of exponentially decaying weighting of n-step returns based targets in λ-returns is a rather ad-hoc design choice. Our major contribution is that we propose a generalization of λ-returns called Confidence-based Autodidactic Returns (CAR), wherein the RL agent learns the weighting of the n-step returns in an end-to-end manner. In contrast to λ-returns wherein the RL agent is restricted to use an exponentially decaying weighting scheme, CAR allows the agent to learn to decide how much it wants to weigh the n-step returns based targets. Our experiments, in addition to showing the efficacy of CAR, also empirically demonstrate that using sophisticated weighted mixtures of multi-step returns (like CAR and λ-returns) considerably outperforms the use of n-step returns. We perform our experiments on the Asynchronous Advantage Actor Critic (A3C) algorithm in the Atari 2600 domain.

1. INTRODUCTION:

Reinforcement Learning (RL) (Sutton & Barto, 1998) is often used to solve goal-directed sequential decision making tasks wherein conventional Machine Learning methods such as supervised learning are not suitable. Goal-directed sequential decision making tasks are modeled as Markov Decision Process (MDP) (Puterman, 2014) . Traditionally, tabular methods were extensively used for solving MDPs wherein value function or policy estimates were maintained for every state. Such methods become infeasible when the underlying state space of the problem is exponentially large or continuous. Traditional RL methods have also used linear function approximators in conjunction with hand-crafted state spaces for learning policies and value functions. This need for hand-crafted task-specific features has limited the applicability of RL, traditionally.

Recent advances in representation learning in the form of deep neural networks provide us with an effective way to achieve generalization (Bengio et al., 2009; LeCun et al., 2015) . Deep neural networks can learn hierarchically compositional representations that enable RL algorithms to generalize over large state spaces. The use of deep neural networks in conjunction with RL objectives has shown remarkable results such as learning to solve the Atari 2600 tasks from raw pixels (Bellemare et al., 2013; Mnih et al., 2015; 2016; Sharma et al., 2017; Jaderberg et al., 2017) , learning to solve complex simulated physics tasks (Todorov et al., 2012; Schulman et al., 2015a; Lillicrap et al., 2015) and showing super-human performance on the ancient board game of Go (Silver et al., 2016; 2017) . Building accurate and powerful (in terms of generalization capabilities) state and action value function (Sutton & Barto, 1998) estimators is important for successful RL solutions. This is because many practical RL solutions (Q-Learning (Watkins & Dayan, 1992) , SARSA (Rummery & Niranjan, 1994) and Actor-Critic Methods (Konda & Tsitsiklis, 2000) ) use Temporal Difference (TD) Learning (Sutton, 1988) . In TD learning, a n-step return is used as an estimate of the value function by means of bootstrapping from the n th state's value function estimate. On the other hand, in Monte Carlo learning, the cumulative reward obtained in the entire trajectory following a particular state is used as an estimate for the value function of that state. The ability to build better estimates of the value functions directly results in better policy estimates as well as faster learning. λ-returns (LR) (Sutton & Barto, 1998) are very effective in this regard. They are effective for faster propagation of delayed rewards and also result in more reliable learning. LR provide a trade-off between using complete trajectories (Monte Carlo) and bootstrapping from n-step returns (TD learning). They model the TD target using a mixture of n-step returns, wherein the weights of successively longer returns are exponentially decayed. With the advent of deep RL, the use of multi-step returns has gained a lot of popularity (Mnih et al., 2016) . However, it is to be noted that the use of exponentially decaying weighting for various n-step returns seems to be an ad-hoc design choice made by LR. In this paper, we start off by extensively benchmarking λ-returns (our experiments only use truncated λ-returns due to the nature of the DRL algorithm (A3C) that we work with and we then propose a generalization called the Confidence-based Autodidactic Returns (CAR), In CAR, the DRL agent learns in an end-to-end manner, the weights to assign to the various n-step return based targets. Also in CAR, it's important to note that the weights assigned to various n-step returns change based on the different states from which bootstrapping is done. In this sense, CAR weights are dynamic and using them represents a significant level of sophistication as compared to the usage of λ-returns.

In summary, our contributions are: 1. To alleviate the need for some ad-hoc choice of weights as in the case of λ-returns, we propose a generalization called Autodidactic Returns and further present a novel derivative of it called Confidence-based Autodidactic Returns (CAR) in the DRL setting.

2. We empirically demonstrate that using sophisticated mixtures of multi-step return methods like λ-returns and Confidence-based Autodidactic Returns leads to considerable improvement in the performance of a DRL agent.

3. We analyze how the weights learned by CAR are different from that of λ-returns, what the weights signify and how they result in better estimates for the value function.

2. BACKGROUND:

In this section, we present some basic concepts required to understand our work.

2.1. PRELIMINARIES:

An MDP (Puterman, 2014) is defined as the tuple S, A, r, P, γ , where S is the set of states in the MDP, A is the set of actions, r : S × A → R is the reward function, P : S × A × S → [0, 1] is the transition probability function such that s p(s, a, s ) = 1, p(s, a, s ) ≥ 0, and γ ∈ [0, 1) is the discount factor. We consider a standard RL setting wherein the sequential decision-making task is modeled as an MDP and the agent interacts with an environment E over a number of discrete time steps. At a time step t, the agent receives a state s t and selects an action a t from the set of available actions A. Given a state, the agent could decide to pick its action stochastically. Its policy π is in general a mapping defined by: π : S × A → [0, 1] such that a∈A π(s, a) = 1, π(s, a) ≥ 0 ∀s ∈ S, ∀a ∈ A. At any point in the MDP, the goal of the agent is to maximize the return, defined as: G t = ∞ k=0 γ k r t+k which is the cumulative discounted future reward. The state value function of a policy π, V π (s) is defined as the expected return obtained by starting in state s and picking actions according to π.

2.2. ACTOR CRITIC ALGORITHMS:

Actor Critic algorithms (Konda & Tsitsiklis, 2000) are a class of approaches that directly parameterize the policy (using an actor) π θa (a|s) and the value function (using a critic) V θc (s). They update the policy parameters using Policy Gradient Theorem (Sutton et al., 1999; Silver et al., 2014) based objective functions. The value function estimates are used as baseline to reduce the variance in policy gradient estimates.

2.3. ASYNCHRONOUS ADVANTAGE ACTOR CRITIC:

Asynchronous Advantage Actor Critic(A3C) (Mnih et al. (2016) ) introduced the first class of actor-critic algorithms which worked on high-dimensional complex visual input space. The key insight in this work is that by executing multiple actor learners on different threads in a CPU, the RL agent can explore different parts of the state space simultaneously. This ensures that the updates made to the parameters of the agent are uncorrelated.

The actor can improve its policy by following an unbiased low-variance sample estimate of the gradient of its objective function with respect to its parameters, given by:

∇ θa log π θa (a t |s t )(G t -V (s t ))

In practice, G t is often replaced with a biased lower variance estimate based on multi-step returns. In the A3C algorithm n-step returns are used as an estimate for the target G t , where n ≤ m and m is a hyper-parameter (which controls the level of rolling out of the policies). A3C estimates G t as:

G t ≈ V (s t ) = n i=1 γ i-1 r t+i + γ n V (s t+n )

and hence the objective function for the actor becomes:

L(θ a ) = log π θa (a t |s t )δ t where δ t = t+j-1 i=t γ i-t r i + γ j V (s t+j ) -V (s t ) is the j-step returns based TD error.

The critic in A3C models the value function V (s) and improves its parameters based on sample estimates of the gradient of its loss function, given as:

∇ θc ( V (s t ) -V θc (s t )) 2 .

2.4. WEIGHTED RETURNS:

Weighted average of n-step return estimates for different n's can be used for arriving at TD-targets as long as the sum of weights assigned to the various n-step returns is 1 (Sutton & Barto (1998) ).

In other words, given a weight vector w = w (1) , w (2) , • • • , w (h) , such that h i=1 w (i) =1, and n-step

returns for n ∈ {1, 2, • • • , h}: G (1) t , G (2) t , • • • , G (h)

t , we define a weighted return as

G w t = h n=1 w (n) G (n) t (1) Note that the n-step return G (n) t

is defined as:

EQUATION

2.5. λ-RETURNS:

A special case of G w t is G λ t (known as λ-returns) which is defined as:

EQUATION

What we have defined here are a form of truncated λ-returns for TD-learning. These are the only kind that we experiment with, in our paper. We use truncated λ-returns because the A3C algorithm is designed in a way which makes it suitable for extension under truncated λ-returns. We leave the problem of generalizing our work to the full λ-returns as well as eligibility-traces (λ-returns are the forward view of eligibility traces) to future work.

3 λ-RETURNS AND BEYOND: AUTODIDACTIC RETURNS

3.1. AUTODIDACTIC RETURNS:

Autodidactic returns are a form of weighted returns wherein the weight vector is also learned alongside the value function which is being approximated. It is this generalization which makes the returns autodidactic. Since the autodidactic returns we propose are constructed using weight vectors that are state dependent (the weights change with the state the agent encounters in the MDP), we denote the weight vector as w(s t ). The autodidactic returns can be used for learning better approximations for the value functions using the TD(0) learning rule based update equation:

EQUATION

In contrast with autodidactic returns, λ-returns assign weights to the various n-steps returns which are constants given a particular λ. We reiterate that the weights assigned by λ-returns don't change during the learning process. Therefore, the autodidactic returns are a generalization and assign weights to returns which are dynamic by construction. The autodidactic weights are learned by the agent, using the reward signal it receives while interacting with the environment.

3.2. CONFIDENCE-BASED AUTODIDACTIC RETURNS:

All the n-step returns for state s t are estimates for V (s t ) bootstrapped using the value function of corresponding n th future state (V (s t+n )). But all those value functions are estimates themselves.

Hence, one natural way for the RL agent to weigh an n-step return G

(n) t would be to compute this weight using some notion of confidence that the agent has in the value function estimate, V (s t+n ), using which the n-step return was estimated. The agent can weigh the n-returns based on how confident it is about bootstrapping from V (s t+n ) in order to obtain a good estimate for V (s t ). We denote this confidence on V (s t+n ) as c(s t+n ). Given these confidences, the weight vector w(s t ) can computed as:

w(s t ) = w(s t ) (1) , w(s t ) (2) , • • • , w(s t ) (m)

where w(s t ) (i) is given by:

w(s t ) (i) = e c(st+i)

j=m j=1 e c(st+j )

(5)

The idea of weighing the returns based on a notion of confidence has been explored earlier (White & White, 2016; Thomas et al., 2015) . In these works, learning or adapting the lambda parameter based on a notion of confidence/certainty under the bias-variance trade-off has been attempted, but the reason why only a few successful methods have emerged from that body of work is due to the difficult of quantifying, measuring and optimizing this certainty metric. In this work, we propose a simple and robust way to model this and we also address the question of what it means for a particular state to have a high value of confidence and how this leads to better estimates of the value function.

3.3. USING λ-RETURNS IN A3C:

λ-returns have been well studied in literature (Peng & Williams, 1996; Sutton & Barto, 1998; Seijen & Sutton, 2014) and have been used in DRL setting as well (Schulman et al., 2015b; Gruslys et al., 2017) . We propose a straightforward way to incorporate (truncated) λ-returns into the A3C framework. We call this combination as LRA3C.

The critic in A3C uses n-step return for arriving at good estimates for the value function. However, note that the TD-target can in general be based on any n-step return (or a mixture thereof). The A3C algorithm in specific is well suited for using weighted returns such as λ-returns since the algorithm already uses n-step return for bootstrapping. Using eqs.

(1) to (3) makes it very easy to incorporate weighted returns into the A3C framework. The sample estimates for the gradients of the actor and the critic respectively become: 

∇ θa log π θa (a t |s t )(G λ t -V (s t )) ∇ θc (G λ t -V θc (s t )) 2

3.4. USING AUTODIDACTIC RETURNS IN A3C:

We propose to use autodidactic returns in place of normal n-step returns in the A3C framework.

We call this combination as CARA3C. In a generic DRL setup, a forward pass is done through the network to obtain the value function of the current state. The parameters of the network are progressively updated based on the gradient of the loss function and the value function estimation (in general) becomes better. For predicting the confidence values, a distinct neural network is created which shares all but the last layer with the value function estimation network. So, every forward pass of the network on state s t now outputs the value function V (s t ) and the confidence the network has in its value function prediction, c(s t ). Figure 1 shows the CARA3C network unrolled over time and it visually demonstrates how the confidence values are calculated using the network. Next, using eqs.

(1) to (5) the weighted average of n-step returns is calculated and used as a target for improving V (s t ). Algorithm 1, in Appendix F , presents the detailed pseudo-code for training a CARA3C agent. The policy improvement is carried out by following sample estimates of the loss function's gradient, given by: ∇ θa log π θa (a t |s t )δ t , where δ t is now defined in terms of the TD error term obtained by using autodidactic returns as the TD-target. Overall, the sample estimates for the gradient of the actor and the critic loss functions respectively are:

∇ θa log π θa (a t |s t )(G w(st) t -V (s t )) ∇ θc (G w(st) t -V θc (s t )) 2

3.5. AVOIDING PITFALLS IN TD LEARNING OF CRITIC:

The LSTM-A3C neural networks for representing the policy and the value function share all but the last output layer. In specific, the LSTM (Hochreiter & Schmidhuber, 1997) controller which aggregates the observations temporally is shared by the policy and the value networks. As stated in the previous sub-section, we extend the A3C network to predict the confidence values by creating a new output layer which takes as input the LSTM output vector (LSTM outputs are the pre-final layer). Figure 1 contains a demonstration of how w(s 1 ) is computed. Since all the three outputs (policy, value function, confidence on value function) share all but the last layer, G w(st) t depends on the parameters of the network which are used for value function prediction. Hence, the autodidactic returns also influence the gradients of the LSTM controller parameters. However, it was observed that when the TD target, G w t , is allowed to move towards the value function prediction V (s t ), it makes the learning unstable. This happens because the L 2 loss between the TD-target and the value function prediction can now be minimized by moving the TD-target towards erroneous value function predictions V (s t ) instead of the other way round. To avoid this instability we ensure that gradients do not flow back from the confidence values computation's last layer to the LSTM layer's outputs. In effect, the gradient of the critic loss with respect to the parameters utilized for the computation of the autodidactic return can no longer influence the gradients of the LSTM parameters (or any of the previous convolutional layers). To summarize, during back-propagation of gradients in the A3C network, the parameters specific to the computation of the autodidactic return do not contribute to the gradient which flows back into the LSTM layer. This ensures that the parameters of the confidence network are learned while treating the LSTM outputs as fixed feature vectors. This entire scheme of not allowing gradients to flow back from the confidence value computation to the LSTM outputs has been demonstrated in Figure 1 . The forward arrows depict the parts of the network which are involved in forward propagation whereas the backward arrows depict the path taken by the back-propagation of gradients.

4. EXPERIMENTAL SETUP AND RESULTS:

We performed general game-play experiments with CARA3C and LRA3C on 22 tasks in the Atari domain. All the networks were trained for 100 million time steps. The hyper-parameters for each of the methods were tuned on a subset of four tasks: Seaquest, Space Invaders, Gopher and Breakout. The same hyper-parameters were used for the rest of the tasks. The baseline scores were taken from Sharma et al. (2017) . All our experiments were repeated thrice with different random seeds to ensure that our results were robust to random initialization. The same three random seeds were used across experiments and all results reported are the average of results obtained by using these three random seeds. Since the A3C scores were taken from Sharma et al. (2017) , we followed the same training and testing regime as well. Appendix A contains experimental details about the training and testing regimes. Appendix G documents the procedure we used for picking important hyper-parameters for our methods. Evolution of the average performance of our methods with training progress has been shown in Figure 2 . An expanded version of the graph for all the tasks can be found in Appendix C. Table 1 Figure 3 : Percentage improvement achieved by CARA3C and LRA3C over A3C.

shows the mean and median of the A3C normalized scores of CARA3C and LRA3C. If the scores obtained by one of the methods and A3C in a task are p and q respectively, then the A3C normalized score is calculated as: p q . As we can see, both CARA3C and LRA3C improve over A3C with CARA3C doing the best: on an average, it achieves over 4× the scores obtained by A3C. The raw scores obtained by our methods against A3C baseline scores can be found in Table 2 (in Appendix B). Figure 3 shows the percentage improvement achieved by sophisticated mixture of n-step return methods (CARA3C and LRA3C) over A3C. If the scores obtained by one of the methods and A3C in a task are p and q respectively, then the percentage improvement is calculated as: p-q q × 100 . As we can see, CARA3C achieves a staggering 67× performance in the task Kangaroo. LRA3C ) to various n-step returns over the duration of an episode by fully trained DRL agents. The four games shown here are games where CARA3C achieves large improvements in performance over LRA3C. It can be seen that for all the four tasks, the difference in weights evolve in a dynamic fashion as the episode goes on. The motivation behind this analysis is to understand how different the weights used by CARA3C are as compared to LRA3C and as it can be seen, it's very different. The agent is clearly able to weighs it's returns in a way that is very different from LRA3C and this, in fact, seems to give it the edge over both LRA3C and A3C in many games. These results once again reiterates the motivation for using dynamic Autodidactic Returns. An expanded version of the graphs for all the tasks can be found in Appendix D. In Figure 5 each bin (x, y) denotes the average confidence value assigned by the network to the states that were encountered during the training time between y million and y + 1 million steps and whose value estimates were changed by a value between x and x + 1 percent, where 0 ≤ x < 100 and 0 ≤ y < 100. In all the graphs we can see that during the initial stages of the training(lower rows of the graph), the confidence assigned to the states is approximately equal irrespective of the change is value estimate. As training progresses the network learns to assign relatively higher confidence values to the states whose value function changes by a small amount than the ones whose value function changes more. So, the confidence value can be interpreted as a value that quantifies the certainty the network has on the value estimate of that state. Thus, weighing the n-step returns based on the confidence values will enable the network to bootstrap the target value better. The confidence value depends on the certainty or the change in value estimate and it is not the other way round, i.e., having high confidence value doesn't make the value estimate of that state to change less. This is true because the confidence value can not influence the value estimate of a state as the gradients obtained from the confidence values are not back propagated beyond the dense layer of confidence output. Figure 6 shows the confidence values assigned to states over the duration of an episode by a fully trained CARA3C DRL agent for two games where CARA3C achieves large improvements over LRA3C and A3C: Kangaroo and Beam Rider.

4.2. ANALYSIS OF DIFFERENCE IN WEIGHTS ASSIGNED BY CARA3C AND LRA3C:



4.3. SIGNIFICANCE OF THE CONFIDENCE VALUES:



4.4. ANALYSIS OF EVOLUTION OF CONFIDENCE VALUES DURING AN EPISODE:

For both the games it's clear that the confidence values change dynamically in response to the states encountered. Here, it's important to note that the apparent periodicity observed in the graphs is not because of the nature of the confidences learnt but is instead due to the periodic nature of the games themselves. From the game frames shown one can observe that the frames with high confidence are highly recurring key states of the game. In case of Beam Rider, the high confidence states correspond to the initial frames of every wave wherein a new horde of enemies (often similar to the previous wave) come in after completion of the penultimate wave in the game. In the case of Kangaroo, apart from many other aspects to the game, there is piece of fruit which keeps falling down periodically along the left end of the screen (can be seen in the game's frames). Jumping up at the appropriate time and punching the fruit gives you 200 points. By observing game-play, we found that the policy learnt by the CARA3C agent identifies exactly this facet of the game to achieve such large improvements in the score. Once again, these series of states encompassing this transition of the fruit towards the bottom of the screen form a set of highly recurring states, Especially states where the piece of fruit is "jumping-distance" away the kangaroo and hence are closer to the reward are found to form the peaks. These observations reiterate the results obtained in Section 4.3 as the highly recurring nature of these states (during training over multiple episodes) would enable the network to estimate these value functions better. The better estimates of these value functions are then suitably used to obtain better estimates for other states by bootstrapping with greater attention to the high confidence states. We believe that this ability to derive from a few key states by means of an attention mechanism provided by the confidence values enables CARA3C to obtain better estimates of the value function. An expanded version of the graphs for all the tasks can be found in Appendix E. In this paper, we propose two methods for learning value functions in a more sophisticated manner than using n-step returns. Hence, it is important to analyze the value functions learned by our methods and understand whether our methods are indeed able to learn better value functions than baseline methods or not. For this sub-section we trained a few A3C agents to serve as baselines. To verify our claims about better learning of value functions, we conducted the following experiment. We took trained CARA3C, LRA3C and A3C agents and computed the L 2 loss between the value function V (s t ) predicted by a methods and the actual discounted sum of returns ( T -t k=0 γ k r t+k ). We averaged this quantity over 10 episodes and plotted it as a function of time steps within an episode. Figure 7 demonstrates that our novel method CARA3C learns a much better estimate of the Value function V (s t ) than LRA3C and A3C. The only exception to this is the game of Kangaroo. The reason that A3C and LRA3C critics manage to estimate the value function well in Kangaroo is because the policy is no better than random and in fact their agents often score just around 0 (which is easy to estimate).

4.5. ANALYSIS OF THE LEARNED VALUE FUNCTION:



5. CONCLUSION AND FUTURE WORK:

We propose a straightforward way to incorporate λ-returns into the A3C algorithm and carry out a large-scale benchmarking of the resulting algorithm LRA3C. We go on to propose a natural generalization of λ-returns called Confidence-based Autodidactic returns (CAR). In CAR, the agent learns to assign weights dynamically to the various n-step returns from which it can bootstrap. Our experiments demonstrate the efficacy of sophisticated mixture of multi-steps returns with at least one of CARA3C or LRA3C out-performing A3C in 18 out of 22 tasks. In 9 of the tasks CARA3C performs the best whereas in 9 of them LRA3C is the best. CAR gives the agent the freedom to learn and decide how much it wants to weigh each of its n-step returns.

The concept of Autodidactic Returns is about the generic idea of giving the DRL agent the ability to model confidence in its own predictions. We demonstrate that this can lead to better

:



Figures and Tables:

Figure 1: CARA3C network -Confidence-based weight vector calculation for state s 1 .

Figure 2: Training curves for raw scores obtained by CARA3C and LRA3C.

Figure 4: Difference in weights given by CARA3C and LRA3C to each of the n-step returns (where n ≤ 20) during an episode.

Figure 4 demonstrates the difference in weights assigned by CARA3C and LRA3C (i.e w (i) CARA3Cw (i)

Figure 5: Relation between the confidence assigned to a state and the percent change in their value estimate. Percentage change in value estimates were obtained by calculating the value estimate of a state just before and after a batch gradient update step.

Figure 6: Evolution of confidence over an episode along with game frames for certain states with high confidence values.

Figure 7: Comparison of value function estimates of CARA3C, LRA3C and A3C.

Mean and median of A3C normalized scores across all games.

Table content: <table><tr><td colspan="3">Algorithm Normalized Scores</td></tr><tr><td/><td>Mean</td><td>Median</td></tr><tr><td>A3C</td><td>1.00</td><td>1.00</td></tr><tr><td>LRA3C</td><td>1.63</td><td>1.05</td></tr><tr><td>CARA3C</td><td>4.53</td><td>1.15</td></tr></table>

Peer review (iclr2018):
 SUMMARY The major contribution of the paper is a generalization of lambda-returns called Confidence-based Autodidactic Returns (CAR), wherein the RL agent learns the weighting of the n-step returns in an end-to-end manner. These CARs are used in the A3C algorithm. The weights are based on the confidence of the value function of the n-step return. Even though this idea in not new the authors propose a simple and robust approach for doing it by using the value function estimation network of A3C. During experiments, the autodidactic returns perform better only half of the time as compared to lambda returns. COMMENTS The j-step returns TD error is not written correctly In Figure 1 it is not obvious how the confidence of the values is estimated. Figure 1 is unreadable. A lighter version of Algorithm 1 in Appendix F should be moved in the text, since this is the novelty of the paper.