Augment-Reinforce-Merge Policy Gradient for Binary Stochastic Policy

TL;DR

This paper introduces the ARM policy gradient estimator, a low-variance, unbiased method for binary stochastic policies that improves stability and convergence speed in on-policy reinforcement learning.

Contribution

It proposes the ARM policy gradient estimator for binary actions, providing theoretical variance reduction guarantees and enhanced training stability.

Findings

Achieves variance reduction with theoretical guarantees.

Leads to more stable policy training.

Enables faster convergence of neural network policies.

Abstract

Due to the high variance of policy gradients, on-policy optimization algorithms are plagued with low sample efficiency. In this work, we propose Augment-Reinforce-Merge (ARM) policy gradient estimator as an unbiased low-variance alternative to previous baseline estimators on tasks with binary action space, inspired by the recent ARM gradient estimator for discrete random variable models. We show that the ARM policy gradient estimator achieves variance reduction with theoretical guarantees, and leads to significantly more stable and faster convergence of policies parameterized by neural networks.

Equations

$$J(\pi )={\mathbb{E}}_{\pi }\left[\sum _{t=0}^{T-1}{r}_t{\gamma }^t\right],$$

$$g_{\theta }={\mathbb{E}}_{\pi }\left[\sum _{t=0}^{T-1}{Q}^{\pi }(s_t,a_t){\nabla }_{\theta }\log {\pi }_{\theta }(a_t|s_t)\right].$$

$${\hat{g}}_{\theta }^{(\text{AC})}$$

$$=\sum _{t=0}^{T-1}{A}^{\pi }(s_t,a_t){\nabla }_{\theta }\log {\pi }_{\theta }(a_t|s_t),$$

$$p(z=1|\mathbf{\varphi })=\sigma (\mathbf{\varphi })=\frac{\exp (\varphi )}{\exp (\varphi )+1}$$

$$\underset{{\varphi }_i,1\le i\le V}{\max }{\mathbb{E}}_{\mathbf{z}\sim {\Pi }_{i=1}^V\text{Bernoulli}({\varphi }_i)}[f(\mathbf{z})].$$

$${\mathcal{E}}_{\mathbf{\varphi }}={\mathbb{E}}_{\mathbf{z}\sim {\Pi }_{i=1}^V\text{Bernoulli}({\varphi }_i)}[f(\mathbf{z})]$$

$${\nabla }_{\mathbf{\varphi }}\mathcal{E}(\mathbf{\varphi })={\mathbb{E}}_{\mathbf{u}\sim {\Pi }_{i=1}^V\mathcal{U}(0,1)}\left[f_{\Delta }(\mathbf{u},\mathbf{\varphi })(\mathbf{u}-\frac{1}{2})\right],$$

$$q_{w_{0:T-1}}({\mathbf{b}}_{0:T-1}|\mathbf{x})=q_{w_1}(b_1|\mathbf{x}){\Pi }_{t=1}^{T-1}{q}_{w_{t+1}}({\mathbf{b}}_{t+1}|{\mathbf{b}}_t),$$

$$\mathcal{E}(w_{0:T-1})$$

$$q_{w_t}({\mathbf{b}}_t|{\mathbf{b}}_{t-1})=\text{Bernoulli}(\sigma ({\mathcal{T}}_{w_t}({\mathbf{b}}_{t-1}))),$$

$$\displaystyle\nabla_{w_{t}}\mathcal{E}(w_{0:T-1})=\mathbb{E}_{q(\mathbf{b}_{1:{t-1}})}\bigg{[}\mathbb{E}_{\mathbf{u}_{t}\sim\mathcal{U}(0,1)}\bigg{[}$$

$$f_{\Delta }({\mathbf{u}}_t,$$

$$J(\{{\pi }_{{\theta }_t}\})={\mathbb{E}}_{a_t\sim {\pi }_{{\theta }_t}(\cdot |s_t)}\left[\sum _{t=0}^{T-1}{r}_t{\gamma }^t\right],$$

$${\nabla }_{{\theta }_{t^{\ast }}}J(\{{\pi }_{{\theta }_t}\})={\mathbb{E}}_{u_t^{\ast }\sim U(0,1)}[$$

$$g_{\theta }^{(\text{ARM})}(t^{\ast })={\mathbb{E}}_{u_t^{\ast }\sim U(0,1)}[$$

$$(u_t^{\ast }-\frac{1}{2})]{\nabla }_{{\theta }_{t^{\ast }}}{\mathcal{T}}_{{\theta }_{t^{\ast }}}(s_{t^{\ast }})].$$

$$g_{\theta }^{(\text{ARM})}:=\sum _{t=0}^{T-1}{g}_{\theta }^{(\text{ARM})}(t)$$

$$\mathbb{E}[{\hat{g}}_{\theta }^{\text{(ARM)}}]=g_{\theta }$$

$$(\text{ref}eq:stationaryarmgrad)$$

$$-{\int }_{u<{\pi }_0}\frac{A_0}{{\pi }_0}(u-\frac{1}{2}){\nabla }_{\theta }\varphi du$$

$$=-(\frac{1}{2}{A}_0{\pi }_0-\frac{1}{2}{A}_1{\pi }_1){\nabla }_{\theta }\varphi$$

$$=A_1{\pi }_1{\nabla }_{\theta }\varphi$$

$$g_{\theta }(t)$$

$$\frac{{\sup }_{\theta }\mathbb{V}[{\hat{g}}_{\theta }^{(\text{ARM})}(t)|s_t]}{{\sup }_{\theta }\mathbb{V}[{\hat{g}}_{\theta }(t)|s_t]}\le \frac{16}{25}.$$

$$\underset{\theta }{\sup }\mathbb{V}[{\hat{g}}_{\theta }^{(\text{ARM})}(t)]\le \underset{\theta }{\sup }\mathbb{V}[{\hat{g}}_{\theta }(t)].$$

$$A^{\pi }(s_t,a_t^{(s)})=-\frac{\pi (a_t|s_t)}{1-\pi (a_t|s_t)}{A}^{\pi }(s_t,a_t)$$

$$Q^{\pi }(s_t,a_t^{(s)})-Q^{\pi }(s_t,a_t)=-(\frac{\pi (a_t|s_t)}{1-\pi (a_t|s_t)}+1)A^{\pi }(s_t,a_t)|a_t^{(s)}-a_t|$$

$${\hat{A}}^{\pi }(s_t,a_t)={\hat{Q}}^{\pi }(s_t,a_t)-V_{\varphi }(s_t),$$

$${\delta }_t^V=r_t+\gamma V_{\varphi }(s_{t+1})-V_{\varphi }(s_t),$$

$${\hat{A}}^{\pi }(s_t,a_t)=\sum _{l=0}^{\infty }(\gamma \lambda {)}^l{\delta }_{t+l}^V.$$

$${\hat{g}}_{\theta }^{\text{A2C}}=\frac{1}{\tau }\sum _{t=0}^{\tau -1}{A}_t{\nabla }_{\theta }\log {\pi }_{\theta }(a_t|s_t),$$

$${\hat{g}}_{\theta }^{\text{A2C(r)}}=\frac{1}{\tau }\sum _{t=0}^{\tau -1}{A}_t{\nabla }_{\theta }\log {\pi }_{\theta }(a_t^{(r)}|s_t).$$

Full text

1 Introduction

There has been significant recent interest in deep reinforcement learning (DRL) that combines reinforcement learning (RL) with powerful function approximators such as neural networks, which leads to a wide variety of successful applications, ranging from board/video game playing to simulated/real life robotic control (Silver et al., 2016; Mnih et al., 2013; Schulman et al., 2015a; Levine et al., 2016). One major area of DRL is on-policy optimization (Silver et al., 2016; Schulman et al., 2015a), which progressively improves upon the current policy iterate until a local optima is found.

As on-policy optimization flattens RL into a stochastic optimization problem, unbiased gradient estimation is carried out using REINFORCE or its more stable variants (Williams, 1992; Mnih et al., 2016). In general, however, on-policy gradient estimators suffer from high variance and need many more samples to construct high quality updates. Prior works have proposed variance reduction using variants of control variates (Gu et al., 2015, 2017; Grathwohl et al., 2017; Wu et al., 2018). However, recently Tucker et al. (2018) cast doubts on some aforementioned variance reduction techniques by showing that their implementation deviates from the proposed methods in the paper, which we will detail in the related work below. In other cases, biased gradients are deliberately constructed to heuristically compute trust region policy updates (Schulman et al., 2017b), which also achieve state-of-the-art performance on a wide range of tasks.

In this work, we consider an unbiased policy gradient estimator based on the Augment-Reinforce-Merge (ARM) gradient estimator for binary latent variable models (Yin & Zhou, 2019). We design a practical on-policy algorithm for RL tasks with binary action space, and show that the theoretical guarantee for variance reduction in Yin & Zhou (2019) can be straightforwardly applied to the policy gradient setting. The proposed ARM policy gradient estimator is a plug-in alternative to REINFORCE gradient estimator and its variants (Mnih et al., 2016), with minor algorithmic modifications.

The remainder of the paper is organized as follows. In Section 2, we introduce background and related work on RL and the ARM estimator for binary latent variable models. In Section 3, we describe the ARM policy gradient estimator, including the derivation, theoretical guarantees, and on-policy optimization algorithm. In Section 4, we show via thorough experiments that our proposed estimator consistently outperforms stable baselines, such as the A2C (Mnih et al., 2016) and recently proposed RELAX (Grathwohl et al., 2017) estimators.

2 Background

2.1 Reinforcement Learning

Consider a Markov decision process (MDP), where at time $t$ the agent is in state $s_{t}\in\mathcal{S}$, takes action $a_{t}\in\mathcal{A}$, transitions to next state $s_{t+1}\in\mathcal{S}$ according to $s_{t+1}\sim p(\cdot\,|\,a_{t},s_{t})$ and receives instant reward $r_{t}=r(s_{t},a_{t})\in\mathbb{R}$. A policy is a mapping $\pi:\mathcal{S}\mapsto\mathcal{P}(\mathcal{A})$ where $\mathcal{P}(\mathcal{A})$ is the space of distributions over the action space $\mathcal{A}$. The objective of RL is to search for a policy $\pi$ such that the expected discounted cumulative rewards $J(\pi)$ is maximized

[TABLE]

where $\gamma\in(0,1]$ is a discount factor and $T$ is the horizon. Let $\pi^{\ast}=\arg\max_{\pi}J(\pi)$ be the optimal policy. For convenience, we define under policy $\pi$ the value function as $V^{\pi}(s)=\mathbb{E}[\sum_{t=0}^{T-1}r_{t}\gamma^{t}\,|\,s_{0}=s]$ and action-value function as $Q^{\pi}(s,a)=\mathbb{E}[\sum_{t=0}^{T-1}r_{t}\gamma^{t}\,|\,s_{0}=s,a_{0}=a]$. We also define the advantage function as $A^{\pi}(s,a)=Q^{\pi}(s,a)-V^{\pi}(s,a)$. By construction, we have $\mathbb{E}_{a\sim\pi(\cdot\,|\,s)}[A^{\pi}(s,a)]=0$, $i.e.$, the expected advantage $A^{\pi}(s,a)$ under policy $\pi$ is zero.

2.2 On-Policy Optimization

One way to find $\pi\approx\pi^{\ast}$ is through direct policy search. Consider parameterizing the policy $\pi_{\theta}$ with parameter $\theta\in\Theta$ where $\Theta$ is the space of parameters. If the policy class is expressive enough such that $\pi^{\ast}\in\{\pi_{\theta}\,|\,\theta\in\Theta\}$, we can recover $\pi^{\ast}$ with some parameter $\theta^{\ast}$. In on-policy optimization, we start with a random policy $\pi_{\theta}$ and iteratively improve the policy through gradient updates $\theta\leftarrow\theta+\alpha g_{\theta}$ for some learning rate $\alpha>0$. We can compute the gradient

[TABLE]

It is worth noting that $g_{\theta}$ is almost but not exactly the REINFORCE gradient of $J(\pi_{\theta})$ (Williams, 1992). The approximation $g_{\theta}\approx\nabla_{\theta}J(\pi_{\theta})$ is due to the absence of discount factors $\gamma^{t}$ at each term in the summation of (2). In recent practice, $g_{\theta}$ is used instead of the exact REINFORCE gradient $\nabla_{\theta}J(\pi_{\theta})$ since the factor $\gamma^{t}$ aggressively weighs down terms with large $t$ (Schulman et al., 2015a, 2017a; Mnih et al., 2016), which leads to poor empirical performance. In our subsequent derivations, we treat $g_{\theta}$ as the standard gradient and we let $\hat{g}_{\theta}=\sum_{t}Q^{\pi}(s_{t},a_{t})\nabla\log\pi_{\theta}(a_{t}\,|\,s_{t})$ as an one-sample unbiased estimate of $g_{\theta}$ such that $\mathbb{E}[\hat{g}_{\theta}]=g_{\theta}$. However, $\hat{g}_{\theta}$ generally exhibits very high variance and does not entail stable updates. Actor-critic policy gradients (Mnih et al., 2016) subtract the original estimator $\hat{g}_{\theta}$ by a state-dependent baseline function $b(s_{t})$ as a control variate for variance reduction. A near-optimal choice of $b(s_{t})$ is the value function $b(s_{t})\approx V^{\pi}(s_{t})$, which yields the following one-sample unbiased actor-critic gradient estimator

[TABLE]

where we still have $\mathbb{E}[\hat{g}_{\theta}^{(\text{AC})}]=g_{\theta}$. We also call (3) the A2C policy gradient estimator (Mnih et al., 2016). In practice, the action-value function $Q^{\pi}(s_{t},a_{t})$ is estimated via Monte Carlo samples and the value function $V^{\pi}(s_{t})$ is approximated by a parameterized critic $V_{\phi}(s_{t})\approx V^{\pi}(s_{t})$ with parameter $\phi$.

2.3 Augment-Reinforce-Merge Gradient for Binary Random Variable Models

Discrete random variables are ubiquitous in probabilistic generative modeling. For the presentation of subsequent work, we limit our attention to the binary case. Let $z\sim\text{Bernoulli}(\sigma(\boldsymbol{\phi}))$ denote a binary random variable such that

[TABLE]

where $\phi$ is the logit of the Bernoulli probability parameter and $\sigma(\mathbf{\cdot})$ is the sigmoid function. For multi-dimensional distributions, we have a vector of $V\geq 2$ binary random variables $\mathbf{z}$ such that each component $\mathbf{z}_{i}$ follows an independent Bernoulli distribution $\text{Bernoulli}(\boldsymbol{\phi}_{i})$, which is denoted as $\mathbf{z}\sim\Pi_{i=1}^{V}\text{Bernoilli}(\phi_{i})$. In general, we consider an expected optimization objective $f(\mathbf{z})$ of the vector $\mathbf{z}$

[TABLE]

To optimize (5), we can construct a gradient estimator of $\boldsymbol{\phi}$ for iterative updates. Due to the discrete nature of variables $\mathbf{z}$, the REINFORCE gradient estimator is the naive baseline but its variance can be too high to be of practical use. The ARM (Augment-Reinforce-Merge) gradient estimator (Yin & Zhou, 2019) provides the following alternative (See also Theorem 1in (Yin & Zhou, 2019))

Theorem 2.1** (ARM estimator for multivariate binary).**

For a vector of $V$ binary random variables $\mathbf{z}$, the gradient of

[TABLE]

with respect to ${\boldsymbol{\phi}}$, the logits of the Bernoulli distributions can be expressed as

[TABLE]

where $f_{\Delta}(\mathbf{u},\boldsymbol{\phi})=f(\mathbf{z}_{1})-f(\mathbf{z}_{2}),\mathbf{z}_{1}=\mathbf{1}[\mathbf{u}>\sigma(-\boldsymbol{\phi})],\mathbf{z}_{2}=\mathbf{1}[\mathbf{u}<\sigma(\boldsymbol{\phi})]$. Here $\mathbf{1}[\mathbf{u}>\sigma(-\boldsymbol{\phi})]$ is a $V$-dimensional vector with the $i$th component to be $1[u_{i}>\sigma(-\phi_{i})]$ where $1[\cdot]$ is the indicator function.

The ARM gradient estimator was originally derived through a sequence of steps in Yin & Zhou (2019): first, an AR estimator is derived from augmenting the variable space (A) and applying REINFORCE (R); then a final merge step (M) is applied to several AR estimators for variance reduction. It was shown that through the merge step, the resulting ARM estimator is equivalent to the original AR estimator combined with an optimal control variate subject to certain constraints, which leads to substantial variance reduction with theoretical guarantees. We refer the readers to Yin & Zhou (2019) for more details.

2.4 Training Stochastic Binary Network

One important application of the ARM gradient estimator is training stochastic binary neural networks. Consider a binary latent variable model with $T$ stochastic hidden layers $\mathbf{b}_{0:T-1}$ conditional on observations $\mathbf{x}$, we construct their joint distribution as

[TABLE]

where $\mathbf{b}_{0:T-1}$ are binary random variables and the conditional distributions $q_{w_{t+1}}(\mathbf{b}_{t+1}\,|\,\mathbf{b}_{t})$ are Bernoulli distributions parameterized by $w_{t+1}$. In general, we construct the following objective in the form of (5)

[TABLE]

for some function $f(\mathbf{b}_{0:T-1})$. In the context of variational auto-encoder (VAE) (Kingma & Welling, 2013), $\mathcal{E}(w_{0:T-1})$ is the evidence lower bound (ELBO) (Blei et al., 2017). We would like to optimize $\mathcal{E}(w_{0:T-1})$ using gradients $\nabla_{w_{0:T-1}}\mathcal{E}(w_{0:T-1})$, and this is enabled by the following ARM back-propagation theorem. Proposition 6 in Yin & Zhou (2019) addresses the VAE model, but there is no loss of generality when considering a general function $f(\mathbf{b}_{0:T-1})$ as in the following theorem.

Theorem 2.2** (ARM Backpropagation).**

For a stochastic binary network with $T$ binary hidden layers, let $\mathbf{b}_{0}=\mathbf{x}$, construct the conditional distributions as

[TABLE]

for some function $\mathcal{T}_{w_{t}}(\cdot)$. Then the gradient of $\mathcal{E}(w_{0:T-1})$ w.r.t. $w_{t}$ can be expressed as

[TABLE]

where $f_{\Delta}(\mathbf{u}_{t},\mathcal{T}_{w_{t}}(\mathbf{b}_{t-1}),\mathbf{b}_{0:T-1-1})=\mathbb{E}_{\mathbf{b}_{t+0:T-1}\sim q(\mathbf{b}_{t+0:T-1}\,|\,\mathbf{b}_{t}),~{}\mathbf{b}_{t}=\mathbf{1}[\mathbf{u}_{t}>\sigma(-\mathcal{T}_{w_{t}}(\mathbf{b}_{t-1}))]}[f(\mathbf{b}_{0:T-1})]-\mathbb{E}_{\mathbf{b}_{t+0:T-1}\sim q(\mathbf{b}_{t+0:T-1}\,|\,\mathbf{b}_{t}),~{}\mathbf{b}_{t}=\mathbf{1}[\mathbf{u}_{t}<\sigma(\mathcal{T}_{w_{t}}(\mathbf{b}_{t-1}))]}[f(\mathbf{b}_{0:T-1})]$, which can be estimated via a single Monte Carlo sample.

2.5 Related Work

On-Policy Optimization.

On-policy optimization is driven by policy gradients with function approximation (Sutton et al., 2000). Due to the non-differentiable nature of RL, REINFORCE gradient estimator (Williams, 1992) is the default policy gradient estimator. In practice, REINFORCE gradient estimator has very high variance and the updates can become unstable. Recently, Mnih et al. (2016) propose advantage actor critic (A2C), which reduces the variance of the policy gradient estimator using a value function critic. Further, Schulman et al. (2015b) introduce generalized advantage estimation (GAE), a combination of multi-step return and value function critic to trade-off the bias and variance in the advantage function estimation, in order to compute lower-variance downstream policy gradients.

Variance Reduction for Stochastic gradient estimator.

Policy gradient estimators are special cases of the general stochastic gradient estimation of an objective function written as an expectation $\mathbb{E}_{\mathbf{z}}[J(\mathbf{z})]$. To address the typical high-variance issues of REINFORCE gradient estimator, prior works have proposed to add control variates (or baseline functions) for variance reduction (Paisley et al., 2012; Ranganath et al., 2014; Gu et al., 2015; Kucukelbir et al., 2017). Re-parameterization trick greatly reduces the variance when variables $\mathbf{z}$ are continuous and the underlying distribution is re-parametrizable (Kingma & Welling, 2013). When variables $\mathbf{z}$ are discrete, Maddison et al. (2016); Jang et al. (2016) introduce a biased yet low-variance gradient estimator based on continuous relaxation of the discrete variables. More recently, REBAR (Tucker et al., 2017) and RELAX (Grathwohl et al., 2017) construct unbiased gradient estimators by using baseline functions derived from continuous relaxation of the discrete variables, whose parameters need to be estimated online. Yin & Zhou (2019) propose an unbiased estimate motivated as a self-control baseline, and display substantial gains over prior works when $\mathbf{z}$ are binary variables. In this work, we borrow ideas from Yin & Zhou (2019) and extend the ARM gradient estimator for binary stochastic network into ARM policy gradient for RL.

Variance Reduction for Policy Gradients.

By default, the baseline function for REINFORCE on-policy gradient estimator is only state dependent, and the value function critic is typically applied. Gu et al. (2015) propose Taylor expansions of the value functions as the baseline and construct an unbiased gradient estimator. Grathwohl et al. (2017); Wu et al. (2018) propose carefully designed action-dependent baselines, which can construct unbiased gradient estimator while in theory achieving more substantial variance reduction. Despite their reported success, Tucker et al. (2018) observe that subtle implementation decisions cause their code to diverge from the unbiased methods presented in the paper: (1) Gu et al. (2015, 2017) achieve reported gains potentially by introducing bias into their advantage estimates. When such bias is removed, they do not outperform baseline methods; (2) Liu et al. (2018) achieve reported gains over state-dependent baselines potentially because the baselines are poorly trained. When properly trained, state-dependent baselines achieve similar results as the proposed action-dependent baselines; (3) Grathwohl et al. (2017) achieve gains potentially due to a bug that leads to different advantage estimators for their proposed RELAX estimator and the baseline. When this bug is fixed, they do not achieve significant gains. In this work, we propose ARM policy gradient estimator, a plug-in alternative which is unbiased and consistently outperforms A2C and RELAX for tasks with binary action space.

3 Augment-Reinforce-Merge Policy Gradient

Below we present the derivation of Augment-Reinforce-Merge (ARM) policy gradient. The high level idea is that we draw connections between RL and stochastic binary network - for a RL problem of horizon $T$, we interpret the action sequence $a_{0:T-1}$ as the stochastic $\mathbf{b}_{0:T-1}$ and derive the gradient estimator similarly as in Theorem 2.2. We consider RL problems with binary action space $\mathcal{A}=\{0,1\}$.

3.1 Time-Dependent Policy

To make full analogy to stochastic binary networks with $T$ layers, we consider a RL problem with horizon $T$. We make the policy $\pi$ time-dependent by specifying a different policy $\pi_{\theta_{t}}$ for time $t$ with parameter $\theta_{t}$. We define a similar RL objective as (1)

[TABLE]

where we jointly optimize over all $\{\theta_{t}\},0\leq t\leq T-1$. To make the connection between (10) and (8) explicit, we observe the following: we can interpret (10) as a special form of (8) by setting the binary hidden variables as the actions $\mathbf{b}_{t}\coloneqq a_{t}$ and the observation $\mathbf{x}$ as the initial state $s_{0}$. The conditional distribution can be defined as $q_{w_{t}}(\mathbf{b}_{t}\,|\,\mathbf{b}_{t-1})=q_{w_{t}}(a_{t}\,|\,a_{t-1})\coloneqq\pi_{\theta_{t}}(a_{t}\,|\,s_{t})p(s_{t}\,|\,a_{t-1},s_{t-1})$, which consists of the policy $\pi_{\theta_{t}}(a_{t}\,|\,s_{t})$ and the transition dynamics $p(s_{t}\,|\,a_{t-1},s_{t-1})$. Finally we define the objective function $f(\mathbf{b}_{0:T-1})=f(a_{0:T-1})\coloneqq\mathbb{E}_{s_{t}\sim p(\cdot\,|\,a_{t},s_{t-1})}[\sum_{t=0}^{T-1}r(s_{t},a_{t})\gamma^{t}]$, which depends only directly on $a_{0:T-1}$ (after marginalizing out the states $s_{0:T-1}$).

Since the action space is binary, we introduce a policy parameterization similar to stochastic binary network, $i.e.$, $\pi(\cdot\,|\,s_{t})=\text{Bernoulli}(\sigma(\mathcal{T}_{\theta_{t}}(s_{t})))$. For any given $t=t^{\ast}$, consider the ARM estimator of (10) w.r.t. $\theta_{t^{\ast}}$ according to Theorem 2.2. When we sample $a_{t}\sim\pi_{\theta_{t}}(\cdot\,|\,s_{t})$, we can sample a uniform random variable $u_{t}\sim\mathcal{U}(0,1)$ then set $a_{t}=1[u_{t}<\sigma(\mathcal{T}_{\theta_{t}}(s_{t}))]$. We define the pseudo action as $a_{t}^{(s)}=1[u_{t}>\sigma(-\mathcal{T}_{\theta_{t}}(s_{t}))]$. By converting all variables in the binary stochastic network example into their RL counterparts as described above, we can derive the gradient of (10) w.r.t. $\theta_{t}$ for any given $t=t^{\ast}$

[TABLE]

where $Q^{\{\pi_{t}\}}(s,a)$ is defined as $Q^{\{\pi_{t}\}}(s,a)=\mathbb{E}_{a_{t}\sim\pi_{\theta_{t}}(\cdot\,|\,s_{t})}[\sum_{t=0}^{T-1}r_{t}\gamma^{t}\,|\,s_{0}=s,a_{0}=a]$, $i.e.$, the expected cumulative rewards obtained by first executing $a_{0}=a$ at $s_{0}=s$ and following the time-dependent policy thereafter. Notice that this is not exactly the same as the action-value function we defined in Section 2.1 since the policy is time-dependent.

3.2 Stationary Policy

In practice we are interested in a stationary policy, which is invariant over time $a_{t}\sim\pi_{\theta}(\cdot\,|\,s_{t})$. Since we have derived the gradient estimator for a time-dependent policy $\{\pi_{\theta_{t}}\}$, the most naive approach would be to share weights by letting $\theta_{t}\coloneqq\theta$ and linearly combining the per-step gradients (11) across time steps. Since now the policy is stationary, we define $g_{\theta}^{(\text{ARM})}(t)$ as the stationary version of (11) where $Q^{\{\pi_{t}\}}$ is replaced by $Q^{\pi}$

[TABLE]

The combined gradient is

[TABLE]

We denote $\hat{g}_{\theta}^{(\text{ARM})}(t)$ and $\hat{g}_{\theta}^{(\text{ARM})}$ the unbiased sample estimates of $g_{\theta}^{(\text{ARM})}(t)$ and $g_{\theta}^{(\text{ARM})}$ respectively. Importantly, we can show that $\hat{g}_{\theta}^{\text{(ARM)}}$ is unbiased, $i.e.$, $\mathbb{E}[\hat{g}_{\theta}^{\text{(ARM)}}]=g_{\theta}$ where $g_{\theta}$ is the standard gradient defined in Section 2.2. We summarize the result in the following theorem.

Theorem 3.1** (Unbiased ARM policy gradient).**

When the ARM policy gradient is constructed as in (13), it is unbiased w.r.t. the true gradient $g_{\theta}$ of the RL objective

[TABLE]

Proof.

Recall the standard gradient $g_{\theta}$ in (2), we define $g_{\theta}(t)\coloneqq\mathbb{E}_{\pi_{\theta}}[Q^{\pi_{\theta}}(s_{t},a_{t})\nabla_{\theta}\log\pi(a_{t}\,|\,s_{t})]$. Now we show that by combining ARM gradients across all time steps $t$ (which correspond to all layers of a stochastic binary network), we can compute an unbiased policy gradient. Recall the gradient at $t$ is computed based on (12), we explicitly compute the gradient in the following. For simplicity, we remove all dependencies on $t$ and denote $\phi=\mathcal{T}_{\theta}(s_{t})$, $\pi_{1}=\pi(a_{t}=1\,|\,s_{t})=\frac{\exp(\phi)}{1+\exp(\phi)},~{}\pi_{0}=1-\pi_{1}$. Also the advantage function $A_{1}=A^{\pi}(a_{t}=1,s_{t}),A_{0}=A^{\pi}(a_{t}=0,s_{t})$. Assume also $\pi_{1}\geq\pi_{0}$ without loss of generality,

[TABLE]

We also explicitly write down the standard gradient $g_{\theta}(t)$ at time step $t$ with the same notation

[TABLE]

We see that conditional on the same state $s_{t}$, the ARM policy gradient sample estimate $\hat{g}_{\theta}^{(\text{ARM})}(t)$ at time step $t$ has its expectation equal to the standard gradient $g_{\theta}(t)$ at time $t$. To complete the proof, we marginalize out $s_{t}$ via the visitation probability under current policy $\pi_{\theta}$ and sum over time steps: $\mathbb{E}[\hat{g}_{\theta}^{(\text{ARM})}]=\mathbb{E}[\sum_{t}\hat{g}_{\theta}^{(\text{ARM})}(t)]=\sum_{t}g_{\theta}(t)=g_{\theta}$. ∎

3.3 Variance Reduction for ARM Policy Gradient

Here we compare the variance of the ARM policy gradient estimator $\hat{g}_{\theta}^{(\text{ARM})}$ against the REINFORCE gradient estimator $\hat{g}_{\theta}$. Analyzing the variance of the full gradient is very challenging, since we need to account for covariance between gradient components across time steps. We settle for analyzing the variance of each time component $\hat{g}_{\theta}^{(\text{ARM})}(t)$ and $g_{\theta}(t)$ for any $t\geq 0$. Similar analysis has been applied in Fujita & Maeda (2018).

For simple analysis, we assume that all action-value functions (or advantage functions) can be obtained exactly, $i.e.$, we do not consider additional bias and variance introduced by advantage function estimations. Conditional on a given $s_{t}$, we can show with results from Yin & Zhou (2019) that

[TABLE]

Since we have established $\mathbb{E}[\hat{g}_{\theta}^{(\text{ARM})}(t)\,|\,s_{t}]=\mathbb{E}[\hat{g}_{\theta}(t)\,|\,s_{t}]$, we can show via the variance decomposition formula $\mathbb{V}[g]=\mathbb{E}[\mathbb{V}[g\,|\,s]]+\mathbb{V}[\mathbb{E}[g\,|\,s]]$ that for $\forall t\geq 0$

[TABLE]

We cannot obtain a tighter bound without making further assumptions on the relative scale of variance $\mathbb{V}[\hat{g}_{\theta}(t)\,|\,s_{t}]$ and the expectations $\mathbb{E}[\hat{g}_{\theta}(t)\,|\,s_{t}]$. Still, we can show that the ARM policy gradient estimator can achieve potentially much smaller variance than the standard gradient estimator, which entails faster policy optimization in practice.

We provide an intuition for why ARM policy gradient estimator can achieve substantial variance reduction and stabilize training in practice. In Figure 1, we show the running average of $|a_{t}-a_{t}^{(s)}|$, $i.e.$, the difference between on-policy actions and pseudo actions as training progresses. We show two settings of advantage estimations (left: A2C, right: GAE) which will be detailed in Section 4. We see that as training progresses, both actions are increasingly less likely to be different, often yielding $a_{t}=a_{t}^{(s)}$. In such cases the ARM policy gradient estimator achieves exact zero value $\hat{g}_{\theta}^{(\text{ARM})}=0$. On the contrary, prior baseline gradient estimators (2,3) cannot take up exact zero values and will cause parameters to stumble around due to noisy estimates. We provide more detailed discussions in the Appendix.

3.4 Algorithm

Here we present a practical algorithm that applies the ARM policy gradient estimator. The on-policy optimization procedure should alternate between collecting on-policy samples using current policy and computing gradient estimator using these on-policy samples for parameter updates (Schulman et al., 2015a, 2017a).

We see that a primary difficulty with computing (12) is that it requires the difference of two action-value functions $Q^{\pi}(s_{t},a_{t}^{(s)})-Q^{\pi}(s_{t},a_{t})$. Unless the difference is estimated by additional parameterized critics, in typical on-policy algorithm implementation, we only have access to the Monte Carlo estimators of action-value functions corresponding to on-policy actions. To overcome this, we estimate the difference by using the property $\mathbb{E}_{a\sim\pi(\cdot\,|\,s)}[A^{\pi}(s,a)]=0$. To be specific, when $a_{t}^{(s)}\neq a_{t}$, the advantage function of the pseudo action can be expressed as

[TABLE]

Since the difference of action-value functions is identical to the difference of advantage functions, we have in general

[TABLE]

We can hence estimate the difference in (12) with only on-policy advantage estimates $\hat{A}^{\pi}(s_{t},a_{t})\approx A^{\pi}(s_{t},a_{t})$, along with sampled pseudo action $a_{t}^{(s)}$ and on-policy action $a_{t}$. Notice when $a_{t}^{(s)}=a_{t}$, the difference $Q^{\pi}(s_{t},a_{t}^{(s)})-Q^{\pi}(s_{t},a_{t})=0$, therefore the gradient is zero with high frequency when the algorithm approaches convergence, which leads to faster convergence speed and better stability.

We design the on-policy optimization procedure as follows. At any iteration, we have policy $\pi_{\theta}$ with parameter $\theta$. We generate on-policy rollout at time $t$ by sampling a uniform random variable $u_{t}\sim\mathcal{U}(0,1)$, then construct on-policy action $a_{t}=1[u_{t}\leq\sigma(\mathcal{T}_{\theta}(s_{t}))]$ and pseudo action $a_{t}^{(s)}=1[u_{t}\geq\sigma(-\mathcal{T}_{\theta}(s_{t}))]]$. Only the on-policy actions $a_{t}$ are executed in the environment, which returns instant rewards $r_{t}$. We estimate the advantage functions $A^{\pi_{\theta}}(s_{t},a_{t})$ from on-policy samples using techniques from A2C (Mnih et al., 2016) or GAE (Schulman et al., 2015b), and replace $A^{\pi}(s_{t},a_{t})$ in (12) by estimates $\hat{A}^{\pi}(s_{t},a_{t})$. The details of the advantage estimators are provided in the Appendix. Finally, the difference of the action-value functions can be computed using (18) based purely on on-policy samples. With all the above components, we compute the ARM policy gradient (12) to update the policy parameters. The main algorithm is summarized in Algorithm 1 in the Appendix.

ARM policy gradient as a plug-in alternative.

We note here that despite minor differences in the algorithm ($e.g.$, need to sample pseudo actions $a_{t}^{(s)}$ along with $a_{t}$), ARM policy gradient estimator is a convenient plug-in alternative to other baseline on-policy gradient estimators (2,3). All the other components of standard on-policy optimization algorithms ($e.g.$, value function baselines) remain the same.

4 Experiments

We aim to address the following questions through the experiments: (1) Does the proposed ARM policy gradient estimator outperform previous policy gradient estimators on binary action benchmark tasks? (2) How sensitive are these policy gradient estimators to hyperparameters, $e.g.$, the size of the sample batch size?

To address (1), we compare the ARM policy gradient estimator with A2C gradient estimator (Mnih et al., 2016) and RELAX gradient estimator (Grathwohl et al., 2017). We aim to study how advantage estimators affect the quality of the downstream gradient estimators: with A2C advantage estimation, we compare $\{\text{ARM},\text{A2C},\text{RELAX}\}$ gradient estimators; with GAE, we compare $\{\text{ARM},\text{A2C}\}$ gradient estimators 111Here for A2C gradient estimator, we just replace the original A2C advantage estimators by GAE estimators and keep all other algorithmic components the same.. We evaluate on-policy optimization with various gradient estimators on benchmark tasks with binary action space: for each policy gradient estimator, we train the policy for a fixed number of time steps ($10^{6}$) and across 5 random seeds. Each curve in the plots below shows the mean performance with shaded area as the standard deviation performance across seeds. In Figures 3 and 4, x-axis show the number of time steps at training time and y-axis show the performance. The results are reported in Section 4.1. To address (2), we vary the batch size $\mathcal{B}$ to assess the effects of the batch size on the variance of the policy gradient estimators. We also evaluate the estimators’ sensitivities to learning rates. The results are reported in Sections 4.2 and 4.3.

Benchmark Environments.

We focus on benchmark environments with binary action space illustrated in Figure 2: All tasks are simulated by OpenAI gym and DeepMind control suite (Todorov, 2008; Brockman et al., 2016; Tassa et al., 2018). Some tasks have binary action space by default. In cases where the action space is a real interval, $e.g.$, $\mathcal{A}=[-1,1]$ for Pendulum, we binarize the action space to be $\mathcal{A}=\{-1,1\}$.

Implementations and Hyper-parameters.

All implementations are in Tensorflow (Abadi et al., 2016) and RL algorithms are based on OpenAI baselines (Dhariwal et al., 2017) 222https://github.com/openai/baselines. All policies are optimized with Adam using best learning rates selected from $\in\{3\cdot 10^{-4},3\cdot 10^{-5}\}$. We refer to the original code of RELAX333https://github.com/wgrathwohl/BackpropThroughTheVoidRL but notice potential issues in their original implementation. We discuss such potential issues in the Appendix. We implement our own version of RELAX (Grathwohl et al., 2017) by modifying the OpenAI baselines (Dhariwal et al., 2017). Recall that on-policy optimization algorithms alternate between collecting batch samples of size $\mathcal{B}$ and then compute gradient estimators based on these samples; here we set $\mathcal{B}=2048$ by default.

Policy Architectures.

We parameterize the logit function $\mathcal{T}_{\theta}(s)$ as a two-layer neural network with state $s$ as input and $64$ hidden units per layer. Each layer applies ReLU non-linearity as the activation function. The output is a logit scalar $\mathcal{T}_{\theta}(s)$ where $\theta$ consists of weight matrices and biases in the neural network. For variance reduction we also parameterize a value function baseline with two hidden layers each with $64$ units, with relu non-linear activation. Both the logit function and the value function have linear activation for the output layer. For RELAX gradient estimator, we use two parameterized baseline functions with two layers, each with $64$ hidden units.

4.1 Benchmark Comparison

Here we compare the ARM policy gradient estimator with two baseline methods: A2C gradient estimator (Mnih et al., 2016) and the unbiased RELAX gradient estimator (Grathwohl et al., 2017). We note some critical implementation details: All gradient estimators require advantage estimation $\hat{A}(s,a)\approx A^{\pi}(s,a)$, we do not normalize the advantage estimates before computing the policy gradients as commonly implemented in Dhariwal et al. (2017). As observed in Tucker et al. (2018), such normalization biases the original gradients for variance reduction, especially for action dependent baselines such as RELAX (Grathwohl et al., 2017). Since our focus is on unbiased gradient estimators, we remove such normalization (Dhariwal et al., 2017) 444Since GAE applies a combination of Monte Carlo returns and value function critics, the advantage estimator is still slightly biased to achieve small variance..

A2C Advantage Estimator.

A2C Advantage estimators are simple combinations of Monte Carlo sampled returns and baseline functions. For $\{\text{ARM},\text{A2C}\}$ the baseline is the value function critic, while for RELAX the baseline is parameterized and trained to minimize the square norm of the gradients computed on mini-batches. Let $\hat{g}_{\theta}^{\text{RELAX}}$ be the RELAX gradient estimator and recall $\hat{g}_{\theta}^{\text{A2C}}$ as the A2C gradient estimator. Define a generalized RELAX gradient as $\hat{g}_{\theta}^{\text{RELAX}}(\tau)=\tau\cdot\hat{g}_{\theta}^{\text{A2C}}+(1-\tau)\cdot\hat{g}_{\theta}^{\text{RELAX}}$ for $\tau\in[0,1]$. When $\tau=1$ we recover an A2C gradient estimator (which is still different from our original A2C gradient estimator since the baseline functions are parameterized and trained differently). When $\tau=0$ we recover the original RELAX estimator. In practice we find that $\tau>0$ tends to significantly outperform the pure RELAX estimator.

In Figure 3, we show the performance of $\{\text{ARM},\text{A2C}\}$ estimators along with RELAX with varying $\tau\in\{0,\frac{1}{2},1\}$. We see that the ARM policy gradient estimator outperforms the other baseline estimators on most tasks: except on Inverted Pendulum, where all estimators tend to learn slowly, while RELAX with $\tau\in\{\frac{1}{2},1\}$ perform the best in terms of mean performance, they do not significantly outperform others when accounting for the standard deviation. For other benchmark tasks, the ARM policy gradient estimator enables significantly faster policy optimization, while other baselines either become very unstable or learn very slowly.

Generalized Advantage Estimator (GAE).

GAE constructs advantage estimates using a more complex combination of Monte Carlo samples and baseline function, to better trade-off bias and variance. By construction, here the baseline function must be value function critic, hence we only evaluate $\{\text{ARM},\text{A2C}\}$.

In Figure 4, we show the comparison. We make several observations: (1) Comparing A2C with GAE, as shown in Figure 4, to A2C with A2C advantage estimator, as shown in Figure 3, we see that in most cases A2C with GAE speeds up the policy optimization significantly. This demonstrates the importance of stable advantage estimation for policy gradient estimator. A notable exception is MountainCar, where A2C with A2C advantage estimator performs better. (2) Comparing ARM with A2C in Figure 4, we still see that the ARM estimator significantly outperforms A2C estimator. For almost all presented tasks, the ARM policy gradient estimator allows for much faster learning and significantly better asymptotic performance.

4.2 Effect of Batch Size

On-policy gradient estimators are plagued by low sample efficiency, and we typically need many samples to construct high-quality gradient estimator. We vary the batch size $\mathcal{B}\in\{256,512,1024,2048\}$ for each iteration and evaluate the final performance of $\{\text{ARM},\text{A2C}\}$ gradient estimators. Here, we use GAE as the advantage estimator. We fix the number of iterations (gradient updates) for training to be $\approx 488$ 555This number of iteration is obtained via $\text{int}(\frac{10^{6}}{2048})$, where $10^{6}$ is the number of training steps and $2048$ is the default batch size.. Under this setting, we expect the variance of the policy gradients to increase with decreasing $\mathcal{B}$ and so does the final performance.

In Figure 5, we show the performance of policies trained via $\{\text{ARM},\text{A2C}\}$ gradient estimators. The x-axis show the batch size $\mathcal{B}$ while y-axis show the cumulative returns of the last 10 training iterations (with standard deviation across 5 seeds). We see that as expected the final performance generally increases as we have larger batch size $\mathcal{B}$. Across all presented tasks, the performance of the ARM gradient estimator significantly dominates that of the A2C gradient estimator. This is also compatible with results in Figures 3 and 4, where the ARM policy gradient estimator achieves convergence with significantly fewer number of training iterations.

4.3 Sensitivity to Hyper-parameters

In addition to batch size, we evaluate the policy gradient estimators’ sensitivity to hyper-parameters such as learning rate and random initialization of parameters. In the following setting, we uniformly at random sample log learning rate $\log\alpha\in[-3,-6]$ and parameter initialization from $5$ settings ($5$ random seeds). We train policies under each hyper-parameter configuration for $10^{6}$ steps and record the performance of the last $50$ iterations. For each policy gradient estimator in $\{\text{ARM},\text{A2C}\}$, we sample $30$ distinct hyper-parameter configurations and plot the quantile plots of their performance in Figure 6. In general, we see that ARM gradient estimator is more robust than A2C gradient estimator across all presented tasks.

5 Conclusion

We propose the ARM policy gradient estimator as a convenient low-variance plug-in alternative to prior baseline on-policy gradient estimators, with a simple on-policy optimization algorithm for tasks with binary action space. We leave the extension to more general discrete action space as exciting future work.

Appendix A Further Experiment Details

A.1 CartPole Environment Setup

The CartPole experiments are defined by an environment parameter $T$ which specifies that the agent can achieve a maximum rewards of $T$ ($i.e.$, balance the system for $T$ time steps before the episode terminates).

In our main experiments, we set $T=200$ for CartPole-v0, $T=500$ for CartPole-v1, $T=1000$ for CartPole-v2 and $T=1500$ for CartPole-v3. The difficulty increases with $T$: with large $T$, the agent is less likely to obtain many full trajectories within a single iteration, making it more difficult for return based estimation; long horizons also make it hard for policy optimization.

A.2 Advantage Estimator

We consider two popular advantage estimators widely in use (Mnih et al., 2016; Schulman et al., 2015b) for on-policy optimization applications. The objective of both estimators are to approximate the advantage function $A^{\pi}(s,a)$ under current policy $\pi$.

A2C Advantage Estimator.

We construct the A2C estimator at time $t$ with the following

[TABLE]

where $\hat{Q}^{\pi}(s_{t},a_{t})=\sum_{l\geq 0}r_{t+l}\gamma^{l}$ are Monte-Carlo estimates of the partial sum of returns (along the sampled trajectories). The critic $V_{\phi}(s)$ is trained by regression over the partial returns to approximate the value function $V_{\phi}(s)\approx V^{\pi}(s)$.

Generalized Advantage Estimator (GAE).

GAE is indexed by two parameters $\gamma$ and $\lambda$, where $\gamma\in(0,1)$ is the discount factor and $\lambda\in(0,1]$ is an additional trace parameter that determines bias-variance trade-off of the final estimation. We define TD-errors

[TABLE]

where $V_{\phi}(s)\approx V^{\pi}(s)$ is a value function critic trained by regression over returns. GAE at time $t$ is computed as a weighted average of TD-errors across time

[TABLE]

Though the optimal $\lambda$ parameter is problem dependent, a common practice is to set $\lambda=0.95$.

A.3 Baseline Implementations

We have compared the ARM policy gradient estimator with A2C policy gradient estimator and recently proposed RELAX gradient estimator. We implement three policy gradient estimators based on OpenAI baselines (Dhariwal et al., 2017). Though each policy gradient estimator requires more or less different implementation variations ($e.g.$, record the pseudo action $a_{t}^{(s)}$ and random noise $u_{t}$ for the ARM policy gradient), we have ensured that these three implementations share as much common structure as possible.

We note that though the RELAX code (Grathwohl et al., 2017) is made available, and their code is built on top of the OpenAI baselines. We did not directly run their code because of potential issues in their original implementation of RELAX. We implement our own version of RELAX and note some of the differences from their code.

Difference 1: Policy gradient computation.

In the following we point out potential issues with the implementation of (Grathwohl et al., 2017) and we refer to the the latest commit to the RELAX repository666https://github.com/wgrathwohl/BackpropThroughTheVoidRL (commit 0e6623d) as of this writing.

Recall that on-policy optimization algorithms alternate between performing rollouts and performing updates based on the rollout samples. At rollout time, $\tau$ on-policy samples $\{s_{t},a_{t},r_{t}\}_{t=0}^{\tau-1}$ are collected. Recall that the A2C policy gradient estimator takes the following form

[TABLE]

where $A_{t}$ are the advantage estimators from the on-policy samples. Importantly in (22), the actions $a_{t}$ should be the on-policy samples - the intuition is that on-sample actions $a_{t}$ match their corresponding advantages $A_{t}$, if $A_{t}>0$ for a certain action $a_{t}$ in state $s_{t}$, the gradient update will increase the probability $\pi_{\theta}(a_{t}|s_{t})$. In some cases, one implements the A2C gradient estimator by re-sampling actions $a_{t}^{(r)}$ at each $s_{t}$ during training, resulting in the following estimator

[TABLE]

We remark that this new gradient estimator with re-sampled actions $a_{t}^{(r)}$ is biased, i.e. $\mathbb{E}[\hat{g}_{\theta}^{\text{A2C(r)}}]\neq\mathbb{E}[\hat{g}_{\theta}^{\text{A2C}}]=g_{\theta}$. The bias comes from the fact that when $a_{t}\neq a_{t}^{(r)}$, we assign the advantage $A_{t}$ to the wrong actions $a_{t}^{(r)}$, leading to mismatched credit assignments. We find the latest version of RELAX code (Grathwohl et al., 2017) implements this biased estimator (23) - in fact they implement the biased estimator for both the A2C baseline and their proposed RELAX gradient estimator.

Specifically, in Tensorflow terminology (Abadi et al., 2016), the advantages $A_{t}$, actions $a_{t}$ and states $s_{t}$ should be input into the loss and gradient computation via placeholders. However, in the RELAX implementation, they input advantages $A_{t}$ and states $s_{t}$ via placeholders, while inputting the actions via train_model.a0 where a0 stands for actions sampled from the policy network train_model. In practice, this will cause the policy model to re-sample an independent set of actions, leading to biased estimates. The re-sampling bias is severe when $a_{t}\neq a_{t}^{(r)}$, especially when the policy is still random during the initial stage of training. Later in the training when the policy becomes more deterministic, the bias decreases since it is more likely that $a_{t}=a_{t}^{(r)}$. In our implementation, we correct such potential bugs.

Difference 2: Average gradients over states not trajectories.

In the original development of RELAX, policy gradients are computed per trajectories and averaged across multiple trajectories. A common practice in on-policy algorithm implementation (Dhariwal et al., 2017) is to average policy gradients across states. We follow this latter practice. As a result, we can collect a fixed number of steps per iteration instead of a fixed number of rollouts (which can result in varying number of steps) as in the original work (Grathwohl et al., 2017). We believe that such practice allows for fair comparison.

Appendix B Algorithm

In the pseudocode below, we omit the training of value function baseline $V_{\phi}(s)\approx V^{\pi}(s)$. Following the common practice (Schulman et al., 2015a; Mnih et al., 2016; Schulman et al., 2017a), the value function baseline is trained by regression over Monte Carlo returns.

Appendix C Further Discussions on ARM Policy Gradient Estimator

For simplicity we fix a state $s$ and use a simplified notation: $A_{1}=A^{\pi}(s,a=1)$, $A_{0}=A^{\pi}(s,a=0)$, $\pi_{1}=\pi(a=1\,|\,s)=\frac{\exp(\phi)}{1+\exp(\phi)}$, and $\pi_{0}=1-\pi_{1}$. Here the logit $\phi$ is parameterized as $\phi=\phi(\theta)$ by parameter $\theta$. Let $u\sim\mathcal{U}(0,1)$ be the noise used for generating actions such that $a=1$ if $u<\sigma(\phi)$ and the pseudo action $a^{(s)}=1$ if $u>\sigma(-\phi)$. Without loss of generality, assume $\phi>0$.

The ARM policy gradient estimator can be simplified to be the following

[TABLE]

The intuition for the estimator is clear: when $A_{1}>A_{0}$, the above expression always updates $\phi$ such that $\pi_{1}$ is increased, whenever $u>\sigma(\phi)$ or $u<\sigma(-\phi)$. Then estimator is exactly zero when $\sigma(-\phi)\leq u\leq\sigma(\phi)$, which will become frequent as the policy becomes less entropic during training.

The A2C gradient estimator is the following

[TABLE]

The intuition for updates are also clear for (25): for example when $A_{1}>0$ (which implies $A_{0}<0$), whenever $u\leq\sigma(\phi)$ or $u>\sigma(\phi)$, the gradient always updates the parameter such that $\pi_{1}$ increases. However, due to the A2C gradient form (25), there are no random noise $u$ that leads to exact zero gradient estimators. This tends to make the updates less stable because even when near a local optima the parameters can still oscillate due to noisy estimates of gradient updates.

We could also compute the expected gradient directly

[TABLE]

Since computing the expected gradients also requires advantage estimators (by replacing $A_{i}$ by their estimators $\hat{A}_{i}$), we call the sample estimate of (26) the expected gradient estimators. Although the expected gradient estimator analytically computes the policy gradient, it suffers a similar issue as the A2C gradient estimator - due to noisy estimates of the advantages, the estimator in (26) can never take on exactly zero values. In practice, as we will show below, when the learning rate is fixed, this causes the policy parameter to oscillate due to noisy estimates and leads to unstable learning.

C.1 Further Experiments Comparing Expected Gradient Estimators

Though the expected gradient estimators analytically compute the policy gradient for parameter updates, it can still suffer from noisy estimates of the advantage function. To be concrete, we illustrate such phenomenon in Figure 7, where we evaluate gradient estimators $\{\text{ARM,A2C}\}$ along with expected gradient estimators. The advantage estimators are A2C advantage estimators. We choose the learning rate $\alpha\in\{3\cdot 10^{-6},1\cdot 10^{-5},3\cdot 10^{-5}\}$ for the expected gradient estimators and $\alpha=3\cdot 10^{-5}$ for $\{\text{ARM,A2C}\}$.

For Figure 7 (a)(c)(d), we show the learning rate $\alpha=3\cdot 10^{-5}$ result for the expected gradient estimator since it achieves the best performance and is comparable with the ARM policy gradient estimator. In these cases, we see that the achieve slightly faster rate of convergence than others, with comparable asymptotic performance in (a)(c). In (d), the asymptotic performance of the expected gradient estimator suffers a bit.

For Figure 7 (b)(e)(f), we show the training curves corresponding to all the learning rates of the expected gradient estimators. In these plots, the expected gradient estimators achieve fast learning during the initial stage of training, yet its performance quickly suffers as a result of unstable learning (notice the sudden drops in performance). Turning down the learning rate from $3\cdot 10^{-5}$ to $3\cdot 10^{-6}$ slightly alleviates such issues at the cost of slower convergence. To fully remedy such problems, we speculate that it is necessary to either introduce an annealing scheme in the learning rate so as to avoid the unstable training, or introduce trust-region based methods to stabilize updates (Schulman et al., 2015a, 2017b). On the other hand, the ARM policy gradient estimator consistently achieves stable policy optimization without additional efforts of learning rate annealing and trust-region based techniques.