# Advantage-Weighted Regression: Simple and Scalable Off-Policy Reinforcement Learning

###### Abstract

In this paper, we aim to develop a simple and scalable reinforcement learning algorithm that uses standard supervised learning methods as subroutines. Our goal is an algorithm that utilizes only simple and convergent maximum likelihood loss functions, while also being able to leverage off-policy data. Our proposed approach, which we refer to as advantage-weighted regression (AWR), consists of two standard supervised learning steps: one to regress onto target values for a value function, and another to regress onto weighted target actions for the policy. The method is simple and general, can accommodate continuous and discrete actions, and can be implemented in just a few lines of code on top of standard supervised learning methods. We provide a theoretical motivation for AWR and analyze its properties when incorporating off-policy data from experience replay. We evaluate AWR on a suite of standard OpenAI Gym benchmark tasks, and show that it achieves competitive performance compared to a number of well-established state-of-the-art RL algorithms. AWR is also able to acquire more effective policies than most off-policy algorithms when learning from purely static datasets with no additional environmental interactions. Furthermore, we demonstrate our algorithm on challenging continuous control tasks with highly complex simulated characters. (Video^{1}^{1}1Supplementary video: xbpeng.github.io/projects/AWR/)

## 1 Introduction

Model-free reinforcement learning can be a general and effective methodology for training agents to acquire sophisticated behaviors with minimal assumptions on the underlying task (mnih2015humanlevel; HeessTSLMWTEWER17; Pathak2017). However, reinforcement learning algorithms can be substantially more complex to implement and tune than standard supervised learning methods. Arguably the simplest reinforcement learning methods are policy gradient algorithms (PoliGrad1999), which directly differentiate the expected return and perform gradient ascent. Unfortunately, these methods can be notoriously unstable and are typically on-policy (or nearly on-policy), often requiring a substantial number of samples to learn effective behaviors. Our goal is to develop a reinforcement learning algorithm that is simple, easy to implement, and can readily incorporate off-policy experience data.

In this work, we propose advantage-weighted regression (AWR), a simple off-policy algorithm for model-free RL. Each iteration of the AWR algorithm simply consists of two supervised regression steps: one for training a value function baseline via regression onto cumulative rewards, and another for training the policy via weighted regression. The complete algorithm is shown in Algorithm 1. AWR can accommodate continuous and discrete actions, and can be implemented in just a few lines of code on top of standard supervised learning methods. Despite its simplicity, we find that AWR achieves competitive results when compared to commonly used on-policy and off-policy RL algorithms, and can effectively incorporate fully off-policy data, which has been a challenge for other RL algorithms. Our derivation of AWR presents an interpretation of our method as a constrained policy optimization procedure, and provides a theoretical analysis of the use of off-policy data with experience replay.

We first revisit the original formulation of reward-weighted regression, an on-policy RL method that utilizes supervised learning to perform policy updates, and then propose a number of new design decisions that significantly improve performance on a suite of standard continuous control benchmark tasks. We then provide a theoretical analysis of AWR, including the capability to incorporate off-policy data with experience replay. Although the design of AWR involves only a few simple design decisions, we show experimentally that these additions provide for a large improvement over previous methods for regression-based policy search, such as reward-weighted regression (RWR) (Peters2007RWR), while also being substantially simpler than more modern methods, such as MPO (abdolmaleki2018maximum). We show that AWR achieves competitive performance when compared to several well-established state-of-the-art on-policy and off-policy algorithms. We further demonstrate our algorithm on challenging control tasks with complex simulated characters.

## 2 Preliminaries

In reinforcement learning, the objective is to learn a control policy that enables an agent to maximize its expected return for a given task. At each time step , the agent observes the state of the environment , and samples an action from a policy . The agent then applies that action, which results in a new state and a scalar reward . The goal is to learn an optimal policy that maximizes the agent’s expected discounted return ,

(1) |

where represents the likelihood of a trajectory under a policy , and is the discount factor. represents the unnormalized discounted state distribution induced by the policy (Sutton1998), and is the likelihood of the agent being in state after following for timesteps.

Our proposed AWR algorithm builds on ideas from reward-weighted regression (RWR) (Peters2010REP), a policy search algorithm based on an expectation-maximization framework, which solves the following supervised regression problem at each iteration:

(2) |

represents the policy at the th iteration of the algorithm, and is the return. The RWR update can be interpreted as solving a maximum likelihood problem that fits a new policy to samples collected under the current policy , where the likelihood of each action is weighted by the exponentiated return received for that action, with a temperature parameter . As an alternative to the EM framework, a similar algorithm can also be derived using the dual formulation of a constrained policy search problem (Peters2010REP).

## 3 Advantage-Weighted Regression

In this work, we propose advantage-weighted regression (AWR), a simple off-policy RL algorithm based on reward-weighted regression. We first provide an overview of the complete advantage-weighted regression algorithm, and then describe its theoretical motivation and analyze its properties. The complete AWR algorithm is summarized in Algorithm 1. Each iteration of AWR consists of the following simple steps. First, the current policy is used to sample a batch of trajectories that are then stored in the replay buffer , which is structured as a first-in first-out (FIFO) queue, as is common for off-policy reinforcement learning algorithms (mnih2015humanlevel; DDPG2016). Then, the entire buffer is used to fit a value function to the trajectories in the replay buffer, which can be done with simple Monte Carlo return estimates . Finally, the same buffer is used to fit a new policy using *advantage-weighted* regression, where each state-action pair in the buffer is weighted according to the exponentiated advantage , with the advantage given by and is a hyperparameter. AWR uses only supervised regression as learning subroutines, making the algorithm very simple to implement. In the following subsections, we first motivate the algorithm as an approximation to a constrained policy search problem, and then extend our analysis to incorporate experience replay.

### 3.1 Derivation

In this section, we derive the AWR algorithm as an approximate optimization of a constrained policy search problem. Our goal is to find a policy that maximizes the expected *improvement* over a sampling policy . We first derive AWR for the setting where the sampling policy is a single Markovian policy. Then, in the next section, we extend our result to the setting where the data is collected from multiple policies, as in the case of experience replay that we use in practice. The expected improvement can be expressed in terms of the advantage with respect to the sampling policy (Kakade2002; TRPOschulman15):

(3) |

where denotes the return obtained by performing action in state and following for the following timesteps, and corresponds to the value function of . This objective differs from the ones used in the derivations of related algorithms, such as RWR and REPS (Peters2007RWR; Peters2010REP; abdolmaleki2018maximum), which maximize the expected return instead of the expected improvement. The expected improvement directly gives rise to an objective that involves the advantage. We will see later that this yields weights for the policy update that differ in a subtle but important way from standard reward-weighted regression. As we show in our experiments, this difference results in a large empirical improvement.

The objective in Equation 3 can be difficult to optimize due to the dependency between and , as well as the need to collect samples from . Following TRPOschulman15, we can instead optimize an approximation of using the state distribution of :

(4) |

Here, matches to first order (Kakade2002), and provides a good estimate of if and are close in terms of the KL-divergence (TRPOschulman15). Using this objective, we can formulate the following *constrained* policy search problem:

(5) | ||||

s.t. | (6) |

The constraint in Equation 6 ensures that the new policy is close to the data distribution of , and therefore the surrogate objective remains a reasonable approximation to . We refer the reader to TRPOschulman15 for a detailed derivation and an error bound.

We can derive AWR as an approximate solution to this constrained optimization. This derivation follows a similar procedure as Peters2010REP, and begins by forming the Langrangian of the constrained optimization problem presented above,

(7) |

where is a Lagrange multiplier. Differentiating with respect to and solving for the optimal policy results in the following expression for the optimal policy

(8) |

with being the partition function. A detailed derivation is available in Appendix A. If is represented by a function approximator (e.g., a neural network), a new policy can be obtained by projecting onto the manifold of parameterized policies,

(9) | ||||

(10) |

While this derivation for AWR largely follows the derivations used in prior work (Peters2010REP; abdolmaleki2018maximum), our expected improvement objective introduces a baseline to the policy update, which as we show in our experiments, is a crucial component for an effective algorithm. We next extend AWR to incorporate experience replay for off-policy training, where the sampling policy is no longer a single policy, but rather a mixture of policies from past iterations.

### 3.2 Experience Replay and Off-Policy Learning

A crucial design decision of AWR is the choice of sampling policy . Standard implementations of RWR typically follow an on-policy approach, where the sampling policy is selected to be the current policy at iteration . This can be sample inefficient, as data collected at each iteration of the algorithms are discarded after a single update iteration. Importance sampling can be incorporated into RWR to reuse data from previous iterations, but at the cost of larger variance from the importance sampling estimator (POWER2008). Instead, we can improve sample efficiency of AWR by incorporating experience replay and explicitly accounting for training data from a mixture of multiple prior policies. As described in Algorithm 1, at each iteration, AWR collects a batch of data using the latest policy , and then stores this data in a replay buffer , which also contains data collected from previous policies . The value function and policy are then updated using samples drawn from . This replay strategy is analogous to modeling the sampling policy as a mixture of policies from previous iterations , where represents the likelihood of a trajectory under a policy from the th iteration, and the weights specify the probabilities of selecting each policy .

We now extend the derivation from the previous section to the off-policy setting with experience replay, and show that Algorithm 1 indeed optimizes the expected improvement over a sampling policy modeled by the replay buffer. Given a replay buffer consisting of trajectories from past policies, the joint state-action distribution of is given by , and similarly for the marginal state distribution . The expected improvement can now be expressed with respect to the set of sampling policies in the replay buffer: . Similar to Equation 3, can be expressed in terms of the advantage of each sampling policies,

(11) |

As before, we can optimize an approximation of using the state distribution of ,

(12) |

In Appendix B, we show that the update procedure in Algorithm 1 optimizes the following objective:

(13) | ||||

s.t. | (14) |

where represents the conditional action distribution defined by the replay buffer. This objective can be solved via the Lagrangian to yield the following update:

(15) |

where the expectations can be approximated by simply sampling from following Line 6 of Algorithm 1. A detailed derivation is available in Appendix B. Note, the baseline in the exponent now consists of an average of the value functions of the different policies. One approach for estimating this quantity would be to fit separate value functions for each policy. However, if only a small amount of data is available from each policy, then could be highly inaccurate (fu19diagnosing). Therefore, instead of learning separate value functions, we fit a single *mean* value function that directly estimates the weighted average of ’s,

(16) |

This loss can also be approximated by simply sampling from the replay buffer following Line 5 of Algorithm 1. The optimal solution is exactly the baseline in Equation 15.

### 3.3 Implementation Details

Finally, we discuss several design decisions that are important for a practical implementation of AWR. An overview of AWR is provided in Algorithm 1. The policy update in Equation 10 requires sampling states from the *discounted* state distribution . However, we found that simply sampling states uniformly from was also effective, and simpler to implement. This is a common strategy used in standard implementations of RL algorithms (baselines). When updating the value function and policy, Monte Carlo estimates can be used to approximate the expected return of samples in , but this can result in a high-variance estimate. Instead, we opt to approximate using TD() to obtain a lower-variance estimate (Sutton1998). TD() is applied by bootstrapping with the value function from the previous iteration. A simple Monte Carlo return estimator can also be used though, as shown in our experiments, but this produces somewhat worse results.
To further simplify the algorithm, instead of adaptively updating the Lagrange multiplier , as is done in previous methods (Peters2007RWR; Peters2010REP; abdolmaleki2018maximum), we find that simply using a fixed constant for is also effective. The weights used to update the policy can occasionally assume excessively large values, which can cause gradients to explode. We therefore apply weight clipping with a threshold to mitigate issues due to exploding weights.

## 4 Related Work

Existing RL methods can be broadly categorized into on-policy and off-policy algorithms (Sutton1998). On-policy algorithms generally update the policy using data collected from the same policy. A popular class of on-policy algorithms is policy gradient methods (Williams1992; PoliGrad1999), which have been shown to be effective for a diverse array of complex tasks (HeessTSLMWTEWER17; Pathak2017; 2018-TOG-deepMimic; Rajeswaran-RSS-18). However, on-policy algorithms are typically data inefficient, requiring a large number of interactions with the environment, making it impractical to directly apply these techniques to domains where environmental interactions can be costly (e.g. robotics and other real world applications). Off-policy algorithms improve sample efficiency by enabling a policy to be trained using data from other sources, such as data collected from different agents or data from previous iterations of the algorithm. Importance sampling is a simple strategy for incorporating off-policy data (Sutton1998; Meuleau00off; Hachiya2009), but can introduce optimization instabilities due to the potentially large variance of the importance sampling estimator. Dynamic programming methods based on Q-function learning can also leverage off-policy data (Precup2001; mnih2015humanlevel; DDPG2016; NAF16; haarnoja18b). But these methods can be notoriously unstable, and in practice, require a variety of stabilization techniques to ensure more consistent performance (Hasselt2016; WangBHMMKF16; Munos2016; RainbowDQN2017; fujimoto18a; nachum2018learning; fu19diagnosing). Furthermore, it can be difficult to apply these methods to learn from fully off-policy data, where an agent is unable to collect additional environmental interactions (fujimoto19offpolicy; BEAR2019).

Alternatively, policy search can also be formulated under an expectation-maximization framework. This approach has lead to a variety of EM-based RL algorithms (Peters2010REP; Neumann2011; abdolmaleki2018maximum), an early example of which is reward-weighted regression (RWR) (Peters2007RWR). RWR presents a simple on-policy RL algorithm that casts policy search as a supervised regression problem. A similar algorithm, relative entropy policy search (REPS) (Peters2010REP), can also be derived from the dual formulation of a constrained policy search problem. RWR has a number appealing properties: it has a very simple update rule, and since each iteration corresponds to supervised learning, it can be more stable and easier to implement than many of the previously mentioned RL methods. Despite these advantages, RWR has not been shown to be an effective RL algorithm when combined with neural network function approximators, as demonstrated in prior work and our own experiments (TRPOschulman15; DuanCHSA16). In this work, we propose a number of modifications to the formulation of RWR to produce an effective off-policy deep RL algorithm, while still retaining much of the simplicity of previous methods.

The most closely related prior works to our method are REPS (Peters2010REP) and MPO (abdolmaleki2018maximum), both of which are based on a constrained policy search formulation, and perform policy updates using supervised regression. The optimization problem being solved in REPS is similar to AWR, but REPS optimizes the expected return instead of the expected improvement. The weights in REPS also contains a Bellman error term that superficially resembles advantages, but are computed using a linear value function derived from a feature matching constraint. Learning the REPS value function requires minimization of a dual function, which is a complex function of the Bellman error, while the value function in AWR can be learned with simple supervised regression. REPS can in principle leverage off-policy data, but the policy iteration procedure proposed for REPS models the sampling policy using only the latest policy, and does not incorporate experience replay with data from previous iterations. More recently, abdolmaleki2018maximum proposed MPO, a deep RL variant of REPS, which applies a partial EM algorithm for policy optimization. The method first fits a Q-function of the current policy via bootstrapping, and then performs a policy improvement step with respect to this Q-function under a trust region constraint that penalizes large policy changes. MPO uses off-policy data for training a Q-function critic via bootstrapping and employs Retrace() for off-policy correction (Munos2016). In contrast, AWR is substantially simpler, as it can simply fit a value function to the observed returns in a replay buffer, and performs weighted supervised regression on the actions to fit the policy. Neumann2009Gerhard proposed LAWER, a kernel-based fitted Q-iteration algorithm where the Bellman error is weighted by the normalized advantage of each state-action pair. This was then followed by a soft-policy improvement step. A similar soft-policy update has also been used in more recent algorithms such as soft actor-critic (haarnoja18b). Similarly to (Neumann2009Gerhard), our method also uses exponentiated advantages to weight the policy update, but does not perform fitted Q-iteration, and instead utilizes off-policy data in a simple constrained policy search procedure.

## 5 Experiments

Our experiments aim to comparatively evaluate the performance of AWR to commonly used on-policy and off-policy deep RL algorithms. We evaluate our method on the OpenAI Gym benchmarks (OpenAIGym), consisting of discrete and continuous control tasks. We also evaluate our method on complex motion imitation tasks with high-dimensional simulated characters, including a 34 DoF humanoid and 82 DoF dog (2018-TOG-deepMimic). We then demonstrate the effectiveness of AWR on fully off-policy learning, by training on static datasets of demonstrations collected from demo policies. Behaviors learned by the policies are best seen in the supplementary video1. Code for our implementation of AWR is available at xbpeng.github.io/projects/AWR/. At each iteration, the agent collects a batch of approximately 2000 samples, which are stored in the replay buffer along with samples from previous iterations. The replay buffer stores 50k of the most recent samples. Updates to the value function and policy are performed by uniformly sampling minibatches of 256 samples from . The value function is updated with 200 gradient steps per iteration, and the policy is updated with 1000 steps. Detailed hyperparameter settings are provided in Appendix C.

### 5.1 Benchmarks

We compare AWR to a number of state-of-the-art RL algorithms, including on-policy algorithms, such as TRPO (TRPOschulman15) and PPO (PPOSchulmanWDRK17), off-policy algorithms, such as DDPG (DDPG2016), TD3 (fujimoto18a), and SAC (SAC18), as well as RWR (Peters2007RWR), which we include for comparison due to its similarity to AWR.^{2}^{2}2While we attempted to compare to MPO (abdolmaleki2018maximum), we were unable to find source code for an implementation that reproduces results comparable to those reported by abdolmaleki2018maximum, and could not implement the algorithm such that it achieves similar performance to those reported by the authors.
TRPO and PPO use the implementations from OpenAI baselines (baselines). DDPG, TD3, and SAC uses the implementations from RLkit (rlkit). RWR is a custom implementation following the algorithm described by Peters2007RWR.

Snapshots of the AWR policies are shown in Figure 2. Learning curves comparing the different algorithms on the OpenAI Gym benchmarks are shown in Figure 3, and Table 1 summarizes the average returns of the final policies across 5 training runs initialized with different random seeds. Overall, AWR shows competitive performance with the state-of-the-art deep RL algorithms. It significantly outperforms on-policy methods such as PPO and TRPO in both sample efficiency and asymptotic performance. While it is not yet as sample efficient as current state-of-the-art off-policy methods, such SAC and TD3, it is generally able to achieve a similar asymptotic performance, despite using only simple supervised regression for both policy and value function updates. The complex Humanoid-V2 task proved to be the most challenging case for AWR, and its performance still lags well behind SAC. Note that RWR generally does not perform well on any of these tasks. This suggests that, although AWR is simple and easy to implement, the particular modifications it makes compared to standard RWR are critical for effective performance. To illustrate AWR’s generality on tasks with discrete actions, we compare AWR to TRPO, PPO, and RWR on LunarLander-v2. DDPG, TD3, and SAC are not easily applicable to discrete action spaces due to their need to backpropagate from the Q-function to the policy. On this discrete control task, AWR also shows strong performance compared to the other algorithms.

### 5.2 Ablation Experiments

To determine the effects of various design decisions, we evaluate the performance of AWR when key components of the algorithm have been removed. The experiments include an on-policy version of AWR (On-Policy), where only data collected from the latest policy is used to perform updates. We also compare with a version of AWR without the baseline (No Baseline), which corresponds to using the standard RWR weights , and another version that uses Monte Carlo return estimates instead of TD() (No TD()). The effects of these components are illustrated in Figure 4. Overall, these design decisions appear to be vital for an effective algorithm, with the most crucial components being the use of experience replay and a baseline. Updates using only on-policy data can lead to instabilities and result in noticeable degradation in performance, which may be due to overfitting on a smaller dataset. This issue might be mitigated by collecting a larger batch of on-policy data per iteration, but this can also negatively impact sample efficiency. Removing the baseline also noticeably hampers performance. Using simple Monte Carlo return estimates instead of TD() seems to be a viable alternative, and the algorithm still achieves competitive performance on some tasks. When combined, these different components yield substantial performance gains over standard RWR.

Task | TRPO | PPO | DDPG | TD3 | SAC | RWR | AWR (Ours) |

Ant-v2 | |||||||

HalfCheetah-v2 | |||||||

Hopper-v2 | |||||||

Humanoid-v2 | |||||||

LunarLander-v2 | |||||||

Walker2d-v2 |

To better evaluate the effect of experience replay on AWR, we compare the performance of policies trained with different capacities for the replay buffer. Figure 4 illustrates the learning curves for buffers of size 5k, 20k, 50k, 100k, and 500k, with 50k being the default buffer size in our experiments. The size of the replay buffer appears to have a significant impact on overall performance. Smaller buffer sizes can result in instabilities during training, which again may be an effect of overfitting to a smaller dataset. As the buffer size increases, AWR remains stable even when the dataset is dominated by off-policy data from previous iterations. In fact, performance over the course of training appears more stable with larger replay buffers, but progress can also become slower. Since the sampling policy is modeled by the replay buffer, a larger buffer can limit the rate at which changes by maintaining older data for more iterations. Due to the trust region penalty in Equation 7, a slower changing also prevents the policy from changing quickly. The replay buffer therefore provides a simple mechanism to trade-off between stability and learning speed.

### 5.3 Motion Imitation

The Gym benchmarks present relatively low-dimensional tasks. In this section, we study how AWR can solve higher-dimensional tasks with complex simulated characters, including a 34 DoF humanoid and 82 DoF dog. The objective of the tasks is to imitate reference motion clips recorded using motion capture from real world subjects. The experimental setup follows the motion imitation framework proposed by 2018-TOG-deepMimic. Motion clips are collected from publicly available datasets (CMUMocap; SFUMocap; Zhang2018MNN). The skills include highly dynamics motions, such as spinkicks and canters (i.e. running), and motions that requires more coordinated movements of the character’s body, such as a cartwheel. Snapshots of the behaviors learned by the AWR policies are available in Figure 5. Table 2 compares the performance of AWR to RWR and the highly-tuned PPO implementation from 2018-TOG-deepMimic. Learning curves for the different algorithms are shown in Figure 6. AWR performs well across the set of challenging skills, consistently achieving comparable or better performance than PPO. RWR struggles with controlling the humanoid, but exhibits stronger performance on the dog. This performance difference may be due to the more dynamic and acrobatic skills of the humanoid, compared to the more standard locomotion skills of the dog.

### 5.4 Off-Policy Learning with Static Datasets

Since AWR is an off-policy RL algorithm, it has the advantage of being able to leverage data from other sources. This not only accelerates the learning process on standard tasks, as discussed above, but also allows us to apply AWR in a fully off-policy setting, where the algorithm is provided with a static dataset of transitions, and then tasked with learning the best possible policy. To evaluate our method in this setting, we use the off-policy tasks proposed by BEAR2019. The objective of these tasks is to learn policies solely from static datasets, without collecting any additional data from the policy that is being trained. The dataset consists of trajectories from rollouts of a demo policy. Unlike standard imitation learning tasks, which only observes the states and actions from the demo policy, the dataset also provides the reward received by the demo policy at each step. The demo policies are trained using SAC on various OpenAI Gym tasks. A dataset of 1 million timesteps is collected for each task.

For AWR, we simply treat the dataset as the replay buffer and directly apply the algorithm without additional modifications. Figure 7 compares AWR with other algorithms when applied to the datasets. We include comparisons to the performance of the original demo policy used to generate the dataset (Demo)
and a behavioral cloning policy (BC). The comparisons also include recent off-policy methods: batch-constrained Q-learning (BCQ) (fujimoto19offpolicy) and bootstrapping error accumulation reduction (BEAR) (BEAR2019), which have shown strong performance on off-policy learning with static datasets.
Note that both of these prior methods are modifications to existing off-policy RL methods, such as TD3 and SAC, which are already quite complex. In contrast, AWR is simple and requires no modifications for the fully off-policy setting.
Despite not collecting any additional data, AWR is able to learn effective policies from these fully off-policy datasets, achieving comparable or better performance than the original demo policies. On-policy methods, such as PPO performs poorly in this off-policy setting. Q-function based methods, such as TD3 and SAC, can in principle handle off-policy data but, as discussed in prior work, tend to struggle in this setting in practice (fujimoto19offpolicy; BEAR2019). Indeed, standard behavioral cloning (BC) often outperforms these standard RL methods.
In this fully off-policy setting, AWR can be interpreted as an *advantage-weighted* form of behavioral cloning, which assigns higher likelihoods to demonstration actions that receive higher advantages. Unlike Q-function based methods, AWR is less susceptible to issues from out-of-distribution actions as the policy is always trained on observed actions from the behaviour data (BEAR2019). AWR also shows comparable performance to BEAR and BCQ, which are specifically designed for this off-policy setting and introduce considerable algorithmic overhead.

## 6 Discussion and Future Work

We presented advantage-weighted regression, a simple off-policy reinforcement learning algorithm, where policy updates are performed using standard supervised learning methods. Despite its simplicity, our algorithm is able to solve challenging control tasks with complex simulated agents, and achieve competitive performance on standard benchmarks compared to a number of well-established RL algorithms. Our derivation introduces several new design decisions, and our experiments verify the importance of these components. AWR is also able to learn from fully off-policy datasets, demonstrating comparable performance to state-of-the-art off-policy methods. While AWR is effective for a diverse suite of tasks, it is not yet as sample efficient as the most efficient off-policy algorithms. We believe that exploring techniques for improving sample efficiency and performance on fully off-policy learning can open opportunities to deploy these methods in real world domains. We are also interested in exploring applications that are particularly suitable for these regression-based RL algorithms, as compared to other classes of RL techniques. A better theoretical understanding of the convergence properties of these algorithms, especially when combined with experience replay, could also be valuable for the development of future algorithms.

## Acknowledgements

We thank Abhishek Gupta and Aurick Zhou for insightful discussions. This research was supported an NSERC Postgraduate Scholarship, a Berkeley Fellowship for Graduate Study, Berkeley DeepDrive, Sony Interactive Entertainment America, Google, NVIDIA, Amazon, and the DARPA Assured Autonomy program.

## References

## Appendix A AWR Derivation

In this section, we derive the AWR algorithm as an approximate optimization of a constrained policy search problem. Our goal is to find a policy that maximize the expected *improvement* over a sampling policy . We start with a lemma from Kakade2002, which shows that the expected improvement can be expressed in terms of the advantage with respect to the sampling policy , where denotes the return obtained by performing action in state and following for the following timesteps, and corresponds to the value function of ,

(17) | |||

(18) | |||

(19) | |||

(20) | |||

(21) |

We can rewrite Equation 22 with an expectation over states instead of trajectories:

(22) | ||||

(23) | ||||

(24) | ||||

(25) |

where represents the unnormalized discounted state distribution induced by the policy (Sutton1998), and is the likelihood of the agent being in state after following for timesteps.

The objective in Equation 25 can be difficult to optimize due to the dependency between and , as well as the need to collect samples from . Following TRPOschulman15, we can optimize an approximation of using the state distribution of ,

(26) |

matches to first order (Kakade2002), and provides a reasonable estimate of if and are similar.
Using this objective, we can formulate the following *constrained* policy search problem:

(27) | ||||

s.t. | (28) | |||

(29) |

Since enforcing the pointwise KL constraint in Equation 28 at all states is intractable, we relax the constraint by enforcing it only in expectation . To further simplify the optimization problem, we relax the hard KL constraint by converting it into a soft constraint with coefficient ,

(30) | ||||

s.t. |

Next we form the Lagrangian,

(31) | ||||

with and corresponding to the Lagrange multipliers. Differentiating with respect to results in

(32) |

Setting to zero and solving for gives

(33) |

(34) |

Since , the second exponential term is the partition function that normalizes the conditional action distribution,

(35) |

The optimal policy is therefore given by,

(36) |

If is represented by a function approximator, the optimal policy can be projected onto the manifold of parameterized policies by solving the following supervised regression problem

(37) | ||||

(38) | ||||

(39) |

## Appendix B AWR Derivation with Experience Replay

In this section, we extend the derivation presented in Appendix A to incorporate experience replay using a replay buffer containing data from previous policies. To recap, the sampling distribution is a mixture of past policies , where the mixture is performed at the trajectory level. First, we define the trajectory distribution , marginal state-action distribution , and marginal state distribution of the replay buffer according to:

(40) |

where the weights specify the probabilities of selecting each policy . The conditional action distribution induced by the replay buffer is given by:

(41) |

Next, using Lemma 6.1 from Kakade2002 (also derived in Appendix A), the expected improvement of over each policy satisfies

(42) |

The expected improvement over the mixture can then be expressed with respect to the individual policies,

(43) | ||||

(44) | ||||

(45) | ||||

(46) |

In order to ensure that the policy is similar to the past policies, we constrain against the conditional action distributions of the replay buffer,

(47) |

Note that constraining against has a number of desirable properties. First, the constraint prevents the policy from choosing actions that are vastly different from all of the policies . Second, the mixture weight assigned to each in the definition of depends on the marginal state density for the particular policy. This property is desirable as the policy is now constrained to be similar to only at states that are likely to be visited by . This then yields the following constrained objective:

(48) | ||||

s.t. | (49) | |||

(50) |

The Lagrangian of the above objective is given by:

(51) | ||||

Solving the Lagrangian following the same procedure as Appendix A leads to an optimal policy of the following form:

(52) |

Finally, if is represented by a function approximator, the optimal policy can be projected onto the manifold of parameterized policies by solving the following supervised regression problem

(53) | ||||

(54) |

One of the challenges of optimizing the objective in Equation 54 is that computing the expected return in the exponent requires rolling out multiple policies starting from the same state, which would require the environment to be resettable to any given state. Therefore, to obtain a more practical objective, we approximate the expected return across policies using a single rollout from the replay buffer,

(55) |

This single-sample estimator results in a biased estimate of the exponentiated advantage, because the expectation with respect to the mixture weights appears in the exponent. But in practice, we find this biased estimator to be effective for our experiments. Therefore, the objective used in practice is given by:

(56) |

where the expectations can be approximated by simply sampling from following Line 6 of Algorithm 1. Note, the baseline in the exponent now consists of an average of the value functions of the different policies. One approach for estimating this quantity would be to fit separate value functions for each policy. However, if only a small amount of data is available from each policy, then could be highly inaccurate. Therefore, instead of learning separate value functions, we fit a single *mean* value function that directly estimates the weighted average of ’s,

(57) |

This loss can also be approximated by simply sampling from the replay buffer following Line 5 of Algorithm 1. The optimal solution is exactly the baseline in Equation 56.

## Appendix C Experimental Setup

In our experiments, the policy is represented by a fully-connected network with 2 hidden layers consisting of 128 and 64 ReLU units respectively (NairRLU2010), followed by a linear output layer. The value function is modeled by a separate network with a similar architecture, but consists of a single linear output unit for the value. Stochastic gradient descent with momentum is used to update both the policy and value function. The stepsize of the policy and value function are and respectively, and a momentum of 0.9 is used for both. The temperature is set to for all experiments, and is used for TD(). The weight clipping threshold is set to 20. At each iteration, the agent collects a batch of approximately 2000 samples, which are stored in the replay buffer along with samples from previous iterations. The replay buffer stores 50k of the most recent samples. Updates to the value function and policy are performed by uniformly sampling minibatches of 256 samples from . The value function is updated with 200 gradient steps per iteration, and the policy is updated with 1000 gradient steps.