Learning in complex action spaces without policy gradients

## Abstract

Abstract Conventional wisdom suggests that policy gradient methods are better suited to complex action spaces than action-value methods. However, foundational studies have shown equivalences between these paradigms in small and finite action spaces (O’Donoghue et al., 2017; Schulman et al., 2017a). This raises the question of why their computational applicability and performance diverge as the complexity of the action space increases. We hypothesize that the apparent superiority of policy gradients in such settings stems not from intrinsic qualities of the paradigm, but from universal principles that can also be applied to action-value methods to serve similar functionality. We identify three such principles and provide a framework for incorporating them into action-value methods. To support our hypothesis, we instantiate this framework in what we term QMLE, for Q-learning with maximum likelihood estimation. Our results show that QMLE can be applied to complex action spaces with a controllable computational cost that is comparable to that of policy gradient methods, all without using policy gradients. Furthermore, QMLE demonstrates strong performance on the DeepMind Control Suite, even when compared to the state-of-the-art methods such as DMPO and D4PG.

## 1 Introduction

In reinforcement learning, policy gradients have become the backbone of solutions for environments with complex action spaces, including those involving large, continuous, combinatorial, or structured subaction spaces (Dulac-Arnold et al., ; OpenAI et al., ; Vinyals et al., ; Hubert et al., ; Ouyang et al., ). In contrast, action-value methods have traditionally been confined to tabular-action models for small and finite action spaces. However, where applicable, such as on the Atari Suite (Bellemare et al., ; Machado et al., ), action-value methods are frequently the preferred approach over policy gradient methods (Kapturowski et al., ; Schwarzer et al., ).

Over the past years, foundational research has shown that the distinction between action-value and policy gradient methods is narrower than previously understood, particularly in the basic case of tabular-action models in small and finite action spaces (see, e.g., Schulman et al., ). Notably, O’Donoghue et al. () established an equivalency between these paradigms, revealing a direct connection between the fixed-points of the action-preferences of policies optimized by regularized policy gradients and the action-values learned by action-value methods. These insights invite further exploration of the discrepancies that emerge as the complexity of action spaces increases.

What are the core principles that underpin the greater computational applicability and performance of policy gradient methods in such settings? In this paper, we identify three such principles. First, policy gradient methods leverage Monte Carlo (MC) approximations for summation or integration over the action space, enabling computational feasibility even in environments with complex action spaces. Second, they employ amortized maximization through a special form of maximum likelihood estimation (namely, the policy gradient itself), iteratively refining the policy to increase the likelihood of selecting high-value actions without requiring brute-force $\operatorname*{arg\,max}$ over the action space. Third, scalable policy gradient methods employ action-in architectures for action-value approximation, which covertly enable representation learning and generalization across the joint state-action space.

Are these principles exclusive to policy gradient methods? We argue that these principles can be adapted to action-value methods. Specifically, instead of using MC methods for summation or integration as in policy gradient methods, they can be used to approximate the $\operatorname*{arg\,max}$ in action-value methods in order to make them computationally scalable for complex action spaces. Moreover, explicit maximum likelihood estimation can be applied to enable caching and iterative refinement of parametric predictors for amortized $\operatorname*{arg\,max}$ approximation. Lastly, action-in architectures can be employed not only as a scalable approach for evaluating a limited set of actions in any given state, but also to enable representation learning and generalization across both states and actions.

We introduce *$Q$-learning with maximum likelihood estimation* (QMLE) to test our hypotheses. Our empirical study shows that QMLE achieves strong performance in environments with complex action spaces, all while matching the computational complexity of policy gradient methods. These results provide evidence that the identified principles are core to the success of policy gradient methods in such environments. Moreover, they support that the principles are not intrinsic to the policy gradient paradigm, but are universal and adaptable to action-value learning for achieving similar qualities.

The idea of using sampling-based approximation of the $\operatorname*{arg\,max}$ in value-based methods has been explored in earlier works. For example, Tian et al. () studied the combination of value iteration and random search in discrete domains, with a tabular mechanism for tracking the best historical value-maximizing action in each state. Kalashnikov et al. () introduced the QT-Opt algorithm, which employs a fixed stochastic search via the cross-entropy method to approximate $\operatorname*{arg\,max}$ in Q-learning. Closely related to QMLE is the AQL algorithm by de Wiele et al. (), which integrates Q-learning with entropy-regularized MLE to approximate a value-maximizing action distribution. While QMLE shows superior performance relative to QT-Opt and AQL in complex action spaces (§C), our emphasis in this work is less on algorithmic novelty and more on dissecting the core principles that bridge the gap between the two paradigms.

## 2 Background

### 2.1 The reinforcement learning problem

The reinforcement learning (RL) problem (Sutton & Barto, ) is generally described as a Markov decision process (MDP) (Puterman, ), defined by the tuple $\langle\mathcal{S},\mathcal{A},\mathcal{P},\mathcal{R}\rangle$, where $\mathcal{S}$ is a state space, $\mathcal{A}$ is an action space,
$\mathcal{P}:\mathcal{S}\times\mathcal{A}\rightarrow\Delta(\mathcal{S})$(^1^11$\Delta$ denotes a distribution.) is a state-transition function, and $\mathcal{R}:\mathcal{S}\times\mathcal{A}\times\mathcal{S}\rightarrow\Delta(
\mathbb{R})$ is a reward function.
The behavior of an agent in an RL problem can be formalized by a policy $\pi:\mathcal{S}\rightarrow\Delta(\mathcal{A})$, which maps a state to a distribution over actions. The value of state $s$ under policy $\pi$ may be defined as the expected discounted sum of rewards:
$V^{\pi}(s)\doteq\mathbb{E}_{\pi,\mathcal{P},\mathcal{R}}[\sum_{t=0}^{\infty}
\gamma^{t}r_{t+1}|s_{0}=s]$, where $\gamma\in(0,1)$ is a discount factor used to exponentially decay the present value of future rewards.(^2^22Discounts are occasionally employed to specify the true optimization objective, whereby they should be regarded as part of the MDP. However, more often discounts serve as a hyper-parameter (van Seijen et al., ).)

The goal of an RL agent is defined as finding an optimal policy $\pi^{*}$ that maximizes this quantity across the state space: $V^{\pi^{*}}\geq V^{\pi}$ for all $\pi$. While there may be more than one optimal policy, they all share the same state-value function: $V^{*}=V^{\pi^{*}}$. Similarly, we can define the value of state $s$ and action $a$ under policy $\pi$: $Q^{\pi}(s,a)\doteq\mathbb{E}_{\pi,\mathcal{P},\mathcal{R}}[\sum_{t=0}^{\infty}
\gamma^{t}r_{t+1}|s_{0}=s,a_{0}=a]$. Notice that the goal can be equivalently phrased as finding an optimal policy $\pi^{*}$ that maximizes this alternative quantity across the joint state-action space: $Q^{\pi^{*}}\geq Q^{\pi}$ for all $\pi$. Same as before, optimal policies share the same action-value function: $Q^{*}=Q^{\pi^{*}}$.

The state and action value functions are related to each other via: $V^{\pi}(s)=\sum_{a}Q^{\pi}(s,a)\pi(a|s)$, where we use $\sum$ to signify both summation and integration over discrete or continuous actions. For all MDPs there is always at least one deterministic optimal policy, which can be deduced by maximizing the optimal action-value function: $\operatorname*{arg\,max}_{a}Q^{*}(s,a)$ in any given state $s$. It is worth noting that there may be cases where multiple actions yield the same maximum value, resulting in ties. By breaking such ties at random, considering all conceivable distributions, we can construct the set of all optimal policies, including both deterministic and stochastic policies. Regardless of the optimal policy, the optimal state-value and action-value functions are related to each other in the following way: $V^{*}(s)=\max_{a}Q^{*}(s,a)$.
Similarly, the optimal state-value function can be used to extract optimal policies by invoking the Bellman recurrence: $\operatorname*{arg\,max}_{a}\mathbb{E}_{\mathcal{P},\mathcal{R}}[r_{t+1}+
\gamma V^{*}(s_{t+1})|s_{t}=s]$.
However, this requires access to the MDP model, rendering the sole optimization of state-values unsuitable for model-free RL.

### 2.2 Action-value learning

Optimizing the action-value function and deducing an optimal policy from it seems to be the most direct approach to solving the RL problem in a model-free manner. To this end, we first consider the Bellman recurrence for action-values (Bellman, ):

$$ $Q^{\pi}(s,a)=\mathbb{E}_{\pi,\mathcal{P},\mathcal{R}}[r_{t+1}+\gamma Q^{\pi}(s _{t+1},a_{t+1})|s_{t}=s,a_{t}=a],$ (1) $$

where $\pi$ is in general a stochastic policy and $a_{t+1}\sim\pi(.|s_{t+1})$. By substituting policy $\pi$ with an optimal policy $\pi^{*}$ and invoking $Q^{*}(s,\operatorname*{arg\,max}_{a}Q^{*}(s,a))=\max_{a}Q^{*}(s,a)$, we can rewrite Eq. 1:

$$ $Q^{*}(s,a)=\mathbb{E}_{\mathcal{P},\mathcal{R}}[r_{t+1}+\gamma\max_{a^{\prime} }Q^{*}(s_{t+1},a^{\prime})|s_{t}=s,a_{t}=a].$ (2) $$

The method of temporal differences (TD) (Sutton, ) leverages equations (1) and (2) to contrive two foundational algorithms for model-free RL: Sarsa (Rummery & Niranjan, ) and Q-learning (Watkins, ).
Sarsa updates its action-value estimates, $Q(s_{t},a_{t})$, by minimizing the TD residual:

$$ $\Big{(}r_{t+1}+\gamma Q(s_{t+1},a_{t+1})\Big{)}-Q(s_{t},a_{t}),$ (3) $$

whereas Q-learning does so by minimizing the TD residual:

$$ $\Big{(}r_{t+1}+\gamma\max_{a}Q(s_{t+1},a)\Big{)}-Q(s_{t},a_{t}).$ (4) $$

Both algorithms have been shown to converge to the unique fixed-point $Q^{*}$ of Eq. 2 under similar conditions, with one additional and crucial condition for Sarsa (Watkins & Dayan, ; Jaakkola et al., ; Singh et al., ). Namely, because Sarsa uses the action-value of the action chosen by its policy in the successor state, the action-values can converge to optimality in the limit only if it chooses actions greedily in the limit: $\lim_{k\rightarrow\infty}\pi_{k}(a|s)=\bm{1}_{\mathrm{a=\operatorname*{arg\,
max}_{a^{\prime}}Q(s,a^{\prime})}}$. This is in contrast with Q-learning which uses its maximum action-value in the successor state regardless of its policy, thus liberating its learning updates from how it chooses to act. This key distinction makes Sarsa an *on-policy* and Q-learning an *off-policy* algorithm.
As a final point, the action-value function can be approximated by a parameterized function $Q$, such as a neural network, with parameters $\bm{\mathbf{\omega}}$ and trained by minimizing the squared form of the TD residual (3) or (4).

### 2.3 Policy gradient methods

Unlike action-value methods (§2.2), policy gradient methods do not require an action-value function for action selection. Instead they work by explicitly representing the policy using a parameterized function $\pi$, such as a neural network, with parameters $\bm{\mathbf{\theta}}$ and only utilizing action-value estimates to learn the policy parameters. To demonstrate the main idea underpinning policy gradient methods, we start from the following formulation of the RL problem (cf. §2.1):

$$ $\pi^{*}\doteq\operatorname*{arg\,max}_{\pi}\mathbb{E}_{\pi,\mathcal{P}}\Big{[} V^{\pi}(s_{t})\Big{]}.$ (5) $$

The objective function in this formulation is the expected state-value function, where the expectation is taken over the state distribution induced by policy $\pi$ and state-transition function $\mathcal{P}$. This problem can be solved approximately via gradient-based optimization. In fact, this forms the basis of policy gradient methods. Accordingly, the policy gradient theorem (Sutton et al., ) proves that the gradient of the expected state-value function with respect to policy parameters $\bm{\mathbf{\theta}}$ is governed by:

$$ $\nabla\mathbb{E}_{\pi,\mathcal{P}}\Big{[}V^{\pi}(s_{t})\Big{]}=\nabla\mathbb{E }_{\pi,\mathcal{P}}\Big{[}\sum_{a}Q^{\pi}(s_{t},a)\pi(a|s_{t})\Big{]}\propto \mathbb{E}_{\pi,\mathcal{P}}\Big{[}\sum_{a}Q^{\pi}(s_{t},a)\nabla\pi(a|s_{t}) \Big{]}.$ (6) $$

By using an estimator of the above expression, denoted $\widehat{\nabla J(\bm{\mathbf{\theta}})}$, policy parameters can be updated via stochastic gradient ascent: $\bm{\mathbf{\theta}}\leftarrow\bm{\mathbf{\theta}}+\alpha\widehat{\nabla J(\bm
{\mathbf{\theta}})}$, where $\alpha$ is a positive step-size. It is important to note that, like Sarsa (§2.2), policy gradients are on-policy learners: applying one step of policy gradient updates the policy parameters $\bm{\mathbf{\theta}}\rightarrow\bm{\mathbf{\theta}}^{\prime}$ and thereby the policy $\pi\rightarrow\pi^{\prime}$, thus inducing a different action-value function $Q^{\pi}\rightarrow Q^{\pi^{\prime}}$ and a different state distribution.

There have been attempts to extend policy gradients to off-policy data (Degris et al., ). The most common approach in this direction is to use deterministic policy gradients (DPG; Silver et al., ):

$$ $\displaystyle\nabla\mathbb{E}_{\pi,\mathcal{P}}\Big{[}V^{\pi}(s_{t})\Big{]}$ $\displaystyle=\nabla\mathbb{E}_{\pi,\mathcal{P}}\Big{[}\int Q^{\pi}(s_{t},a) \delta\big{(}a-\pi(s_{t})\big{)}\textrm{d}a\Big{]}$ (7a) $\displaystyle=\nabla\mathbb{E}_{\pi,\mathcal{P}}\Big{[}Q^{\pi}\big{(}s_{t},\pi (s_{t})\big{)}\Big{]}$ (7b) $\displaystyle\propto\mathbb{E}_{\pi,\mathcal{P}}\Big{[}\nabla_{a}Q^{\pi}\big{( }s_{t},a\!=\!\pi(s_{t})\big{)}\nabla\pi(s_{t})\Big{]}.$ (7c) $$

This is similar to Eq. 6 with the difference that here we replace the general-form policy $\pi(a|s)$ with a deterministic and continuous policy $\delta\big{(}a-\pi(s)\big{)}$, where $\delta$ denotes the delta function whose parameters are given by $\pi(s)$. Moreover, this derivation only holds in continuous action spaces and, as such, we substitute our general-form notation $\sum$ for both summation and integration with $\int$ to specify integration over continuous actions. The expression (7b) is then derived from (7a) by invoking the sifting property of the delta function and (7c) is deduced from (7b) by applying the chain rule, yielding a gradient with respect to actions (denoted $\nabla_{a}$) and another with respect to policy parameters $\bm{\mathbf{\theta}}$
(denoted as before by the shorthand $\nabla$).

To implement an off-policy method using DPG, we must make two key changes to the true deterministic policy gradient (7). First, the deterministic policy—which is the target of optimization by DPG—generally differs from the behavior policy $\pi(a|s)$ that the agent uses to interact with and explore the environment. Therefore, we must modify our notation to reflect this distinction:

$$ $\mathbb{E}_{\pi,\mathcal{P}}\Big{[}\nabla_{a}Q^{\mu}\big{(}s_{t},a\!=\!\mu(s_{ t})\big{)}\nabla\mu(s_{t})\Big{]},$ (8) $$

where
$\mu$ denotes the parameters of the delta function $\delta$ and
the expectation is computed with respect to the state distribution induced under behavior policy $\pi$ and state-transition function $\mathcal{P}$. Second, our estimator $Q\approx Q^{\mu}$ must be differentiable with respect to actions. This is typically achieved by training a parameterized function $Q$ by minimizing the squared form of the TD residual:

$$ $\Big{(}r_{t+1}+\gamma Q\big{(}s_{t+1},\mu(s_{t+1})\big{)}\Big{)}-Q(s_{t},a_{t}).$ (9) $$

This expression can be viewed as substituting $Q(s_{t+1},\mu(s_{t+1}))$ for $\max_{a}Q(s_{t+1},a)$ in the TD expression (4), which is used by Q-learning.

### 2.4 Maximum likelihood estimation

Suppose we have a data set $\{(x_{i},y_{i})\}$ drawn from an unknown joint distribution $p(x,y)$, where random variables $x_{i}$ and $y_{i}$ respectively represent inputs and targets. Frequently, problem scenarios involve determining the parameters of an assumed probability distribution that best describe the data. The method of maximum likelihood estimation (MLE) addresses this by posing the question: “Under which parameter values is the observed data most likely?”. In this context, we typically start by representing our assumed distribution using a parameterized function $f$, such as a neural network, with parameters $\bm{\mathbf{\theta}}$. Hence, $\bm{\mathbf{\phi}}\doteq f(x)$ serves as our estimator for the distributional parameters in $x$. For example, $\bm{\mathbf{\phi}}$ contains $K$ values in the case of a categorical distribution with $K$ categories, and contains means $\bm{\mathbf{\mu}}$ and variances $\bm{\mathbf{\sigma}}$ in the case of a multivariate heteroscedastic Gaussian distribution. We will denote the probability distribution that is specified by parameters $\bm{\mathbf{\phi}}=f(x)$ as $f(y|x)$. The problem of finding the optimal parameters can then be formulated as:

$$ $\operatorname*{arg\,max}_{\bm{\mathbf{\phi}}}\mathbb{E}_{p(x,y)}\Big{[}\log f( y_{i}|x_{i})\Big{]}.$ (10) $$

This problem can be solved approximately via gradient-based optimization by leveraging the log-likelihood gradient with respect to parameters $\bm{\mathbf{\theta}}$:

$$ $\mathbb{E}_{p(x,y)}\Big{[}\nabla\log f(y_{i}|x_{i})\Big{]}.$ (11) $$

By using estimates of the above expression, denoted $\widehat{\nabla J(\bm{\mathbf{\theta}})}$, we can iteratively refine our distributional parameters $\bm{\mathbf{\phi}}$ via stochastic gradient ascent on $\bm{\mathbf{\theta}}$: $\bm{\mathbf{\theta}}\leftarrow\bm{\mathbf{\theta}}+\alpha\widehat{\nabla J(\bm
{\mathbf{\theta}})}$, where $\alpha$ is a positive step-size.

## 3 The principles underpinning scalability in policy gradients

As we discussed in Section 2.2, both Sarsa and Q-learning require maximization of the action-value function: Sarsa relies on greedy action-selection in the limit for optimal convergence
and Q-learning needs maximizing the action-value function in the successor state to compute its TD target. Additionally, both Sarsa and Q-learning need action-value maximization in the current state for exploitation or, more generally, for constructing their policies (e.g. an $\varepsilon$-greedy policy relies on choosing greedy actions with probability $1-\varepsilon$ and uniformly at random otherwise). However, performing exact maximization in complex action spaces is computationally prohibitive. This has in turn limited the applicability of Sarsa and Q-learning to small and finite action spaces. On the other hand, policy gradient methods are widely believed to be
suitable for dealing with complex action spaces. In this section, we identify the core principles underlying the scalability of policy gradient methods and describe each such principle in isolation.

### 3.1 Approximate summation or integration using Monte Carlo methods

The scalability of policy gradients in their general stochastic form relies heavily on the identity:

$$ $\displaystyle\mathbb{E}_{\pi,\mathcal{P}}\Big{[}\sum_{a}Q^{\pi}(s_{t},a)\nabla \pi(a|s_{t})\Big{]}$ $\displaystyle=\mathbb{E}_{\pi,\mathcal{P}}\Big{[}Q^{\pi}(s_{t},a_{t})\frac{ \nabla\pi(a_{t}|s_{t})}{\pi(a_{t}|s_{t})}\Big{]}$ (12) $\displaystyle=\mathbb{E}_{\pi,\mathcal{P}}\Big{[}Q^{\pi}(s_{t},a_{t})\nabla \log\pi(a_{t}|s_{t})\Big{]},$ $$

where the middle expression is derived from our original policy gradient expression (6) by substituting an importance sampling estimator in place of the exact summation or integration over the action space.(^4^44Importance sampling is a Monte Carlo (MC) method used for sampling-based approximation of sums and integrals (Hammersley & Handscomb, ).) The rightmost expression is then derived simply by invoking the logarithm differentiation rule, where $\log$ denotes the natural logarithm. Consequently, using an experience batch of the usual form $\{(s_{t},a_{t},r_{t+1},s_{t+1})\}$ with size $n$, we can construct an estimator of the policy gradient as follows:

$$ $\frac{1}{n}\sum_{t}Q^{\pi}(s_{t},a_{t})\nabla\log\pi(a_{t}|s_{t}),$ (13) $$

where $Q^{\pi}$ is the true action-value function under policy $\pi$ which itself needs to be estimated from experience, e.g. via $Q^{\pi}(s_{t},a_{t})\approx r_{t+1}+\gamma V(s_{t+1})$ with $V$ serving as a learned approximator of $V^{\pi}$.

Considering the fact that the policy gradient estimator (13) is founded upon replacing the exact summation or integration over the action space with an on-trajectory (single-action) MC estimator, we can construct a more general class of policy gradient estimators by enabling off-trajectory action samples to also contribute to this numerical computation (Petit et al., ):

$$ $\frac{1}{n}\sum_{t}{\color[rgb]{0.33203125,0.0390625,0.78515625}\frac{1}{m+1}} \Big{(}Q^{\pi}(s_{t},a_{t})\nabla\log\pi(a_{t}|s_{t}){\color[rgb]{ 0.33203125,0.0390625,0.78515625}~{}+\sum_{i=0}^{m-1}Q^{\pi}(s_{t},a_{i})\nabla \log\pi(a_{i}|s_{t})}\Big{)},$ (14) $$

where $m$ is the number of off-trajectory action samples $a_{i}\sim\pi(.|s_{t})$ per state $s_{t}$.
When $m=0$, this reduces to the original on-trajectory policy gradient estimator (13). It is important to note that using the policy gradient estimator (14) with $m>0$ requires direct approximation of the action-values $Q^{\pi}$ by a function $Q$, e.g. a neural network trained by minimizing the squared form of the TD residual (3).

A large portion of policy gradient algorithms rely on the on-trajectory estimator (13), including REINFORCE (Williams, ), A3C (Mnih et al., ), and PPO (Schulman et al., ). To our knowledge, surprisingly few algorithms make use of the generalized MC estimator (14), with AAPG (Petit et al., ) and MPO (Abdolmaleki et al., ) being our only references. On the flip side, methods that perform exact summation or integration over the action space are either limited to small and finite action spaces (Sutton et al., ; Allen et al., ) or restricted to specific distribution classes that enable closed-form integration (Silver et al., ; Ciosek & Whiteson, ; ).

### 3.2 Amortized maximization using maximum likelihood estimation

Figure: Figure 1: Policy progression according to the true policy gradient in two distinct bandit problems: (a) reward function and (b) softmax-policy progression over time from a random initialization to a deterministic policy in a multi-armed bandit; (c) delta-policy progression in a continuous bandit problem with bimodal rewards; (d) fixed-variance Gaussian-policy progression in the same continuous bandit problem. In (c) and (d), policy progressions overlay the reward function.
Refer to caption: x1.png

In RL and dynamic programming, generalized policy iteration (GPI) (Bertsekas, ) represents a class of solution methods for optimizing a policy by alternating between estimating the value function under the current policy (*policy evaluation*) and enhancing the current policy (*policy improvement*). Sarsa is an instance of GPI, wherein the policy evaluation step involves learning of an estimator $Q\approx Q^{\pi}$ by minimizing the temporal difference (3) and the policy improvement step occurs implicitly by acting semi-greedily with respect to $Q$. Policy gradient methods share a close connection to GPI as well (Schulman et al., ). They also alternate between policy evaluation (i.e. estimating $Q\approx Q^{\pi}$) and policy improvement (i.e. updating an explicit policy using an estimate of the policy gradient). Notably, one can instantiate a policy gradient algorithm by performing the policy evaluation step in the same fashion as Sarsa. From this standpoint, the mechanism employed for policy improvement is the main differentiator between policy gradient methods and action-value methods like Sarsa. In the previous section, we illustrated how policy gradient estimation can be carried out in a computationally scalable manner. In this section, we delve into the question of how updating the policy using policy gradients achieves policy improvement, and how it does so in an efficient manner.

We start with recasting the log-likelihood gradient (11) using RL terminology, replacing the variables $(x,y,i,f)$ with $(s,a,t,\pi)$. Moreover, we reinterpret the expectation computation to be under the joint visitation distribution of state-action pairs within an RL context.
Subsequently, we contrast the reframed log-likelihood gradient against the policy gradient (12):

$$ $\underbrace{\mathbb{E}_{\pi,\mathcal{P}}\Big{[}\nabla\log\pi(a_{t}|s_{t})\Big{ ]}}_{\textrm{{{\color[rgb]{0.33203125,0.0390625,0.78515625}log-likelihood gradient}}}}\;\;\;\;\textrm{vs.}\;\;\;\;\underbrace{\mathbb{E}_{\pi,\mathcal{P }}\Big{[}{\color[rgb]{0.33203125,0.0390625,0.78515625}Q^{\pi}(s_{t},a_{t})} \nabla\log\pi(a_{t}|s_{t})\Big{]}}_{\textrm{{{\color[rgb]{ 0.33203125,0.0390625,0.78515625}policy gradient}}}}.$ (15) $$

This comparison implies that policy gradients perform a modified form of MLE, wherein the log-likelihood gradient term is weighted by $Q^{\pi}$ for each state-action pair. This weighting assigns importance to actions according to the product of $Q^{\pi}(s,a)$ and $\log\pi(a|s)$. Therefore, a single step of the true policy gradient updates the policy distribution such that actions with higher action-values become more likely. From this perspective, policy gradients can be construed as a form of amortized inference (Gershman & Goodman, ). Each step of the true policy gradient improves the current approximate maximizer of an interdependent action-value function, with the policy functioning as a mechanism for retaining and facilitating retrieval of the best approximation thus far. To elucidate this, we consider a basic one-state MDP (aka. multi-armed bandit) with deterministic rewards (Fig. 1a). In such a setting, true action-values are independent of the policy and are equivalent to rewards: $Q^{\pi}(a)=Q^{*}(a)=r(a)$ for all $\pi$ and $a$. For learning, we use a tabular policy function with a softmax distribution and update it using the true policy gradient in each step. These choices minimize confounding effects, allowing us to study the way policy gradients achieve policy improvement in isolation. Figure 1b shows the progression of the policy distribution during training, starting from a random initialization until convergence. Early in training the policy captures the ranking of actions according to their respective action-values. In other words, sampling from the policy corresponds to performing a probabilistic $\operatorname*{arg\,sort}$ on the action-value function. In the absence of any counteractive losses, such as entropy regularization, this process continues until convergence to a deterministic policy corresponding to the $\operatorname*{arg\,max}$ over the action-value function.

We have discussed that policy gradients can be viewed as an iterative approach to action-value maximization. However, they do not always yield the global $\operatorname*{arg\,max}$. This limitation is rooted in local tendencies of gradient-based optimization, affecting scenarios with non-tabular policy distributions (Tessler et al., ). Figures 1c,d respectively show progression of a delta policy and a fixed-variance Gaussian policy in a continuous bandit problem with bimodal and deterministic rewards. In both cases, policy improvement driven by policy gradients results in local movement in the action space and thus convergence to sub-optimal policies.

### 3.3 Representation learning via action-in architectures

There are two functional forms for constructing an approximate action-value predictor $Q$: action-in and action-out architectures. An action-in architecture predicts $Q$-values for a given state-action pair at input. An action-out architecture outputs $Q$ predictions for all possible actions in an input state. Action-out architectures have the computational advantage that a single forward pass through the predictor collects all actions’ values in a given state, versus requiring as many forward passes as there are actions in a state by an action-in architecture. Of course, such an advantage is only pertinent when evaluating all possible actions, or a considerable subset of them, in a given state—a necessity that varies depending on the algorithm. On the other hand, one notable limitation of action-out architectures is their incapacity to predict $Q$-values in continuous action domains without imposing strict modeling constraints on the functional form of the estimated $Q$-function (Gu et al., ).

Action-value methods are commonly employed with action-out architectures, including DQN (Mnih et al., ) and Rainbow (Hessel et al., ). Conversely, policy gradient algorithms that involve $Q$ approximations resort to action-in architectures for tackling complex action spaces, such as DDPG (Lillicrap et al., ) and MPO (Abdolmaleki et al., ). Considering the specific requisites of the two families of methods in their standard forms, these are reasonable choices. In particular, standard action-value methods require evaluation of all possible actions in a given state in order to perform the maximization operation, thereby an action-out architecture is more efficient from a computational perspective. In contrast, policy gradient methods that rely on $Q$ approximation require evaluation of only one or a fixed number of actions in any given state (§3.1). Hence, using action-in architectures in the context of policy gradient methods is more computationally efficient in finite action spaces and one that functionally supports $Q$ evaluation in complex action spaces.

So far, we have compared action-in and action-out architectures from computational and functional standpoints.
Now, we turn to a fundamental but often overlooked advantage of action-in architectures: their capacity for representation learning and generalization with respect to actions. Specifically, by treating both states and actions as inputs, action-in architectures unify the process of learning representations for both. For example, when training an action-in $Q$ approximator with deep learning, backpropagation enables learning representations over the joint state-action space. In contrast, action-out architectures are limited in their capacity for generalizing across actions (Zhou et al., ). This limitation arises because, although many layers may serve to learn deep representations of input states, action conditioning is introduced only at the output layer in a tabular-like form. While some action-out architectures introduce structural inductive biases that support combinatorial generalization across multi-dimensional actions (see, e.g., Tavakoli et al., ; ), they do not capacitate action representation learning and generalization in the general form. Moreover, such architectures remain limited to discrete action spaces and are, generally, subject to statistical biases.

## 4 Incorporating the principles into action-value learning

In Section 3, we identified three core principles that we argued underpin the effectiveness of popular policy gradient algorithms in complex action spaces. In this section, we challenge the conventional wisdom that policy gradient methods are inherently more suitable in tackling complex action spaces by showing that the same principles can be integrated into action-value methods, thus enabling them to exhibit similar scaling properties to policy gradient methods without the need for policy gradients.

#### Principle 1

In the same spirit as using an MC estimator in place of exact summation or integration over the action space in policy gradient methods (§3.1), the first principle that we consolidate into action-value learning is substituting exact maximization over the action space with a sampling-based approximation. Formally, we compute an approximation of $\max_{a}Q(s,a)$ via the steps below:

$$ $\displaystyle\textsf{A}_{m}\doteq\{a_{i}\}_{m}\sim\Delta_{\text{search}}( \mathcal{A}_{s})$ (16) $\displaystyle\operatorname*{arg\,max}_{a}Q(s,a)\approx\operatorname*{arg\,max} _{a_{i}\in\textsf{A}_{m}}Q(s,a_{i})\doteq a^{\text{max}}$ (17) $\displaystyle\max_{a}Q(s,a)\approx Q(s,a^{\text{max}})$ (18) $$

where $m\geq 1$ is the number of action samples in state $s$ and $\Delta_{\text{search}}$ is a probability distribution over the generally state-conditional action space $\mathcal{A}_{s}$. Without any prior information, opting for a uniform $\Delta_{\text{search}}$ is ideal as it ensures equal sampling across all possible actions in a given state. This approach, with a constant $m$, allows for action-value learning at a fixed computational cost in arbitrarily complex action spaces (be it discrete, continuous, or hybrid).

#### Principle 2

The next principle is to equip action-value learning with a mechanism for retention and retrieval of the best $\operatorname*{arg\,max}$ approximation so far, analogous to the policy function in policy gradient methods (§3.2). To do so, let us assume we maintain a memory buffer $\mathcal{B}\doteq\{(s_{t},a_{t}^{\text{max}})\}$, where $a_{t}^{\text{max}}$ denotes our best current $\operatorname*{arg\,max}$ approximation in a visited state $s_{t}$. In small and finite state spaces, the memory buffer itself can serve as a basic mechanism for retention and retrieval via table-lookup (as used by Tian et al., ):

$$ $\displaystyle\text{$a^{\text{max}}_{t}\leftarrow\mathcal{B}(s_{t})$ {if} $s_{t }$ {in} $\mathcal{B}$ {otherwise} $\varnothing$}.$ (19) $$

In this case, we can enable the reuse of past computations for amortized $\operatorname*{arg\,max}$ approximations by modifying Eq. 16 in the following way:

$$ $\displaystyle\textsf{A}_{m}\doteq\{a^{\text{max}}_{t}\}\cup\{a_{i}\}_{m-1}\sim \Delta_{\text{search}}(\mathcal{A}_{s}).$ (20) $$

Then, we refine the $\operatorname*{arg\,max}$ approximation via Eq. 17 and update the buffer $\mathcal{B}(s_{t})\leftarrow a^{\text{max}}_{t}$. This approach does not achieve generalization across states, thus compromising its general efficacy in major ways. To enable a capacity for generalization, we resort to training a state-conditional parameterized distribution function with MLE (§2.4). In other words, we train a parametric $\operatorname*{arg\,max}$ predictor $f_{\bm{\mathbf{\theta}}}(.|s_{t})$ by employing the log-likelihood gradient (11) on the stored tuples $\{(s_{t},a_{t}^{\text{max}})\}$.
Notably, this paradigm naturally supports training an ensemble of such predictors, for example based on different distributions.
Therefore, we can rewrite Eq. 20 to explicitly incorporate an ensemble of $k$ parametric $\operatorname*{arg\,max}$ predictors as below:

$$ $\mathsf{A}_{m}=\bigcup\left\{\begin{aligned} &\mathsf{A}_{m_{0}}\sim\text{ Uniform}(\mathcal{A}_{s_{t}})\\ &\mathsf{A}_{m_{1}}\sim f_{\bm{\mathbf{\theta}}_{1}}(.|s_{t})\\ &\cdots\\ &\mathsf{A}_{m_{k}}\sim f_{\bm{\mathbf{\theta}}_{k}}(.|s_{t})\\ &\text{$\{a^{\text{max}}_{t}\}$ (if a prior approximation exists)}\end{aligned }\right.$ (21) $$

#### Principle 3

The third, and final, principle is to combine action-value learning with action-in instead of action-out architectures in order to enable action-value inference in complex action spaces as well as representation learning and generalization with respect to actions (§3.3). While the other ingredients apply more broadly to both tabular and approximate cases, this last one is only relevant in conjunction with functional approximation. Appendix B.1 provides a neural network architecture from our experiments that exemplifies the action-in approach.

## 5 Experiments

To evaluate our framework, we instantiate *$Q$-learning with maximum likelihood estimation* (QMLE) as an example of integrating the adapted core principles (§4) into approximate Q-learning with deep neural networks (Mnih et al., ).
Appendix A presents the QMLE algorithm in a general form.
Our illustrative study (§5.1) employs a simplified implementation of this algorithm. Appendix B provides the details of the QMLE agent used in our benchmarking experiments (§5.2).

### 5.1 Illustrative example

Figure: Figure 2: QMLE with local sampling approximately subsumes DPG and with added global sampling transcends DPG by circumventing suboptimality, as examined in a continuous 2D bandit with two modes and under three canonical exploration strategies. The trajectory of delta distributions during training (yellow) with endpoints (green) overlay the respective learned $Q$-functions at convergence.
Refer to caption: x2.png

We compare QMLE to the deterministic policy gradient (DPG) algorithm in a continuous 2D bandit problem with deterministic and bimodal rewards (similar to that presented by Metz et al., ).
This problem setting minimizes confounding factors by reducing action-value learning to supervised learning of rewards and eliminating contributions from differing bootstrapping mechanisms in the two methods.
For an apples-to-apples comparison, we constrain QMLE to only a single parametric $\operatorname*{arg\,max}$ predictor based on a delta distribution, mirroring the strict limitation of DPG to delta policies.
We further simplify QMLE by aligning its computation of greedy actions with that of DPG. This ensures the only remaining difference between QMLE and DPG is in how their delta parameters are updated, not in how their greedy actions are computed for constructing behavior policies.
Both methods use the same hyper-parameters, model architecture, and initialization across all experiments.

We examine two simplified variants of QMLE. The first one uses local sampling around the delta parameters for $\operatorname*{arg\,max}$ approximations that are used as targets for MLE training. Precisely, we only allow samples $\mathsf{A}_{m}$ drawn from $\delta_{\bm{\mathbf{\theta}}}(s)+\xi$, where $\delta_{\bm{\mathbf{\theta}}}$ denotes the delta-based $\operatorname*{arg\,max}$ predictor and $\xi$ is a zero-mean Gaussian noise with a standard deviation of 0.001 (cf. Eq. 21). This is akin to computing an MC approximation of $\nabla_{a}Q^{\pi}\big{(}s_{t},a\!=\!\pi(s_{t})\big{)}$ in DPG (7c).
The second variant incorporates global sampling alongside local sampling, by additionally sampling from the uniform distribution of Eq. 21.

Figure 2a depicts the reward function of the bandit, or equally the ground-truth $Q$-function. Figure 2b shows the trajectory of delta distributions during training (yellow) until convergence (green), overlaid on the final learned $Q$-function. DPG (Fig. 2b, left) consistently converges to a local optimum, regardless of the exploration strategy and despite the sufficient accuracy of its learned $Q$-function. QMLE with local sampling (Fig. 2b, middle) behaves similarly to DPG. On the other hand, QMLE with
global sampling (Fig. 2b, right) converges to the global optimum across all exploration strategies.

This study illustrates key properties of QMLE with respect to DPG: subsumption, where QMLE with local sampling approximates DPG updates, and transcendence, where global sampling allows QMLE to overcome the local tendencies of policy gradients and surpass DPG.

Figure: Figure 3: Comparison of QMLE with learning curves of DMPO, and evaluation performances of A3C, DDPG, and D4PG after training for 100M environment steps.
Refer to caption: x3.png

### 5.2 Benchmarking results

In this section, we evaluate QMLE on 18 continuous control tasks from the DeepMind Control Suite (Tassa et al., ). Figure 3 shows learning curves of QMLE alongside the learning curves or final performances of several baselines, including state-of-the-art methods DMPO (Hoffman et al., ) and D4PG (Barth-Maron et al., ), as well as the canonical (on-policy) A3C (Mnih et al., ) and (off-policy) DDPG (Lillicrap et al., ).
Results for DMPO (12 tasks) are from Seyde et al. (), while those for A3C, DDPG, and D4PG (16 tasks) are from Tassa et al. ().

With the exception of the *Finger Turn Hard* task, QMLE consistently performs between DDPG and D4PG. Notably, it matches or outperforms DDPG on 14 out of 16 tasks, with DDPG being the closest counterpart from the policy gradient paradigm to QMLE. Moreover, QMLE substantially exceeds the performance of A3C across all
tasks. This is despite QMLE being trained on 10 to 100$\times$ fewer steps compared to A3C, DDPG, and D4PG.
While QMLE competes well with DMPO in low-dimensional action spaces, it trails in higher-dimensional ones.
Nonetheless, the strong performance of QMLE in continuous control tasks with up to 38 action dimensions, all without policy gradients, in and of itself testifies to the core nature of our identified principles and their adaptability to action-value methods.

## 6 Conclusion

In this paper, we distilled the success of policy gradient methods in complex action spaces into three core principles: MC approximation of sums or integrals, amortized maximization using a special form of MLE, and action-in architectures for representation learning and generalization over actions. We then argued that these principles are not exclusive to the policy gradient paradigm and can be adapted to action-value methods. In turn, we presented a framework for incorporating adaptations of these principles into action-value methods. To examine our arguments, we instantiated QMLE by implementing our adapted principles into approximate Q-learning with deep neural networks. Our results showed that QMLE performs strongly in continuous control problems with up to 38 action dimensions, largely outperforming its closest policy gradient counterpart DDPG. These results provided empirical support for the core nature of our identified principles and demonstrated that action-value methods could adopt them to achieve similar qualities, all without policy gradients. In a comparative study using DPG and two simplified QMLE variants, we highlighted a key limitation of policy gradients and showed how QMLE could overcome it. This study serves as a motivator for a shift from policy gradients toward action-value methods with our adapted principles. It also offers a potential explanation for the improvements observed over DDPG in our benchmarking experiments.

## Appendix A Q-learning with maximum likelihood estimation

Figure: Algorithm 1 QMLE algorithm.

In this section, we present the *$Q$-learning with maximum likelihood estimation* (QMLE) algorithm. Specifically, our presentation is based on integrating our framework (§4) into the deep Q-learning algorithm by Mnih et al. (). In line with this, we make use of experience replay and a target network that is only periodically updated with the parameters of the online network. Importantly, we extend the scope of the target network to encompass the $\operatorname*{arg\,max}$ predictors in QMLE. Although the algorithm does not mandate the use of action-in $Q$ approximators per se, such architectures become necessary for addressing problems with arbitrarily complex action spaces (§3.3).

Algorithm 1 details the training procedures for QMLE. Notably, the algorithm is flexible regarding the composition of the ensemble of $\operatorname*{arg\,max}$ predictors. For instance, the ensemble can consist of a combination of continuous and discrete distributions for problems with continuous action spaces. QMLE introduces several hyper-parameters related to its action-sampling processes. These include the sampling budgets for target maximization, $m_{\text{target}}$, and greedy action selection in the environment, $m_{\text{greedy}}$. Additionally, QMLE uses sample allocation ratios $\{\rho_{0},\rho_{1},\ldots,\rho_{k}\}$, where $\rho_{0}$ corresponds to the proportion of the budget allocated to uniform sampling from the action space, and $\rho_{1}$ through $\rho_{k}$ correspond to the proportions assigned to the ensemble of $k$ parametric $\operatorname*{arg\,max}$ predictors.

To effectively manage training inference costs in QMLE, we recommend allocating a larger budget to $m_{\text{greedy}}$ than to $m_{\text{target}}$.
Since $m_{\text{greedy}}$ is used at most once per interaction step, increasing it incurs relatively little computational burden. In addition, more accurate $\operatorname*{arg\,max}$ approximations during training interactions can lead to higher quality data for learning, making this increase particularly beneficial. In contrast, each training update requires $m_{\text{target}}\times N_{b}$ inferences on the target $Q$-network, where $N_{b}$ is the batch size.
This makes increasing $m_{\text{target}}$ much more costly in terms of training inference costs. On that account, choosing a moderate $m_{\text{target}}$ allows for computational tractability with larger batch sizes. Remarkably, a moderate $m_{\text{target}}$ could also help reduce the overestimation of action-values (Hasselt, ; van Hasselt et al., ). Also, assigning a smaller $m_{\text{target}}$ relative to $m_{\text{greedy}}$ is further justified because target maximization benefits from additional amortization. Specifically, each time a transition is sampled from the memory buffer for experience replay, we use the previously stored $\operatorname*{arg\,max}$ approximation as a prior. This approximation is then recalibrated and updated in the memory buffer for the next time that the transition is sampled for replay.

## Appendix B Experimental details

This section details the specific QMLE instance that we evaluated in our benchmarking experiments. We adopted prioritized experience replay (Schaul et al., ), in place of the uniform variant that was described in Algorithm 1. Furthermore, we deployed QMLE with two $\operatorname*{arg\,max}$ predictors: one based on a delta distribution over the continuous action space, and another based on a factored categorical distribution defined over a finite subset of the original action space (Tang & Agrawal, ).

To build the discrete action support, we applied the bang-off-bang (3 bins) discretization scheme to the action space (Seyde et al., ). For sampling from the delta-based $\operatorname*{arg\,max}$ predictor, we always included the parameter of the delta distribution as the initial sample. Any additional samples were generated through Gaussian perturbations around this parameter using a small standard deviation.

Sections B.1, B.2, and B.3 provide details around the model architecture, hyper-parameters, and implementation of QMLE in our benchmarking experiments, respectively.
Section B.4 details the number of seeds per agent and the computation of our learning curves.

### B.1 Model architecture

Figure: Figure 4: Schematic of the model architecture used with QMLE for our benchmarking experiments. Dashed lines indicate paths without gradient flow during backpropagation.
Refer to caption: x4.png

Figure 4 depicts the model architecture of QMLE in our benchmarking experiments. The model begins with two separate streams, one for the observation inputs and the other for the action inputs. The outputs of these streams are then concatenated and jointly processed by the $Q$-value predictor. Furthermore, the output of the observation stream is separately processed by each $\operatorname*{arg\,max}$ predictor.

In the observation stream, we apply a linear embedding layer with 128 units followed by a residual block (He et al., ) that maintains this width and uses rectified linear unit (ReLU) activation (Nair & Hinton, ). The residual block is succeeded by a layer normalization (LayerNorm) operation (Ba et al., ) and exponential linear unit (ELU) activation (Clevert et al., ).

In the action stream, we apply a linear embedding layer with 128 units. The output of the embedding layer is then directly
followed by LayerNorm and ELU activation.

The outputs from both streams are concatenated and passed through a joint observation-action residual block with 256 units and ReLU activation. Subsequently, we apply LayerNorm and ELU activation. The outputs are then linearly mapped to a single scalar, representing the predicted $Q$-value.

The output of the observation stream is also used as input to the two $\operatorname*{arg\,max}$ predictors. To avoid interference, we prevent backpropagation from the $\operatorname*{arg\,max}$ predictor streams through the shared observation stream. Each $\operatorname*{arg\,max}$ predictor stream leverages a hidden multilayer perceptron (MLP) layer with 128 units and ReLU activation.

In the $\operatorname*{arg\,max}$ predictor stream based on the delta distribution, we produce one output per action dimension. Each output is passed through hyperbolic tangent (Tanh) activation to yield a continuous value constrained within the support of each action dimension in our benchmark. In the $\operatorname*{arg\,max}$ predictor stream based on the factored categorical distribution, we produce three outputs per action dimension.
We apply the softmax function to the outputs for each action dimension, producing multiple softmax distributions over a bang-off-bang discrete action support.

### B.2 Hyper-parameters

Table 1 provides the hyper-parameters of QMLE in our benchmarking experiments.

**Table 1: QMLE hyper-parameters in our benchmarking experiments.**
| Parameter | Value |
| --- | --- |
| $m_{\text{target}}$ | 100 |
| $m_{\text{greedy}}$ | 1000 |
| $\rho_{0}$ (uniform) | 0.9 |
| $\rho_{1}$ (delta) | 0.01 |
| $\rho_{2}$ (factored categorical) | 0.09 |
| step sizes $\alpha_{q},\alpha_{\operatorname*{arg\,max}}$ | 0.0005 |
| update frequency | 10 |
| batch size | 256 |
| training start size | 1000 |
| memory buffer size | 1000000 |
| target network update frequency | 2000 |
| loss function | mean-squared error |
| optimizer | Adam (Kingma & Ba, ) |
| exploration $\varepsilon$ | 0.1 |
| discount factor | 0.99 |
| time limit | 1000 (Tassa et al., ) |
| truncation approach | partial-episode bootstrapping (Pardo et al., ) |
| importance sampling exponent | 0.2 |
| priority exponent | 0.6 |

### B.3 Implementation

Our QMLE implementation is based on the open-source DQN codebase by Huang et al. ().
To support reproducibility, we will make our code publicly available upon publication.

### B.4 Seeds and performance

All curves report the mean undiscounted return over seeds with one standard error.
Performance levels of DDPG, D4PG, and A3C represent the mean over 100 episodes per seed, after training for 100M environment steps.
Table 2 details the number of seeds used for each agent in our experiments, grouped by the source of the results.

**Table 2: Number of seeds used in benchmarking experiments.**
| Agent | Trials |
| --- | --- |
| QMLE | 5 or 10 (depending on the task) |
| Results from Seyde et al. () |  |
| DMPO | 10 |
| Results from Tassa et al. () |  |
| A3C | 15 |
| DDPG | 15 |
| D4PG | 5 |
| Results from Pardo () |  |
| MPO | 10 |
| SAC | 10 |
| TD3 | 10 |
| PPO | 10 |
| TRPO | 10 |
| A2C | 10 |
| Results from de Wiele et al. () |  |
| AQL | 3 |
| QT-Opt | 3 |

## Appendix C Supplementary results

Figures 5 and 6 provide comparisons of QMLE with a range of mainstream policy gradient methods. The baseline results are due to Pardo ().

- •
Figure 5 presents a comparison between QMLE and policy gradient methods that rely on action-value approximation: MPO (Abdolmaleki et al., ), SAC (Haarnoja et al., ), and TD3 (Fujimoto et al., ).
- •
Figure 6 compares QMLE with policy gradient methods that use state-value approximation: PPO (Schulman et al., ), TRPO (Schulman et al., ), and A2C (Mnih et al., ).

Figure 7 shows a comparison of QMLE with QT-Opt (Kalashnikov et al., ) and both the discrete and continuous action variants of AQL (de Wiele et al., ). The baseline results are taken from de Wiele et al. ().

Figure: Figure 5: Learning curves of QMLE against MPO, SAC, and TD3.
Refer to caption: x5.png

Figure: Figure 6: Learning curves of QMLE against PPO, TRPO, and A2C.
Refer to caption: x6.png

Figure: Figure 7: Comparison of QMLE with QT-Opt and AQL.
Refer to caption: x7.png

## Appendix D Future work

### D.1 Combining with other improvements

In this paper, we integrated our framework into the deep Q-learning algorithm of Mnih et al. (), in a proof-of-concept agent that we termed QMLE (Algorithm 1). In our benchmarking experiments, we further combined QMLE with prioritized experience replay (Schaul et al., ; see details in Section B). While this setup is relatively basic compared to the advancements in deep Q-learning, it served our purpose of demonstrating the general competency of action-value methods in complex action spaces without involving policy gradients. We anticipate that a purposeful integration with advancements in deep Q-learning could significantly improve the performance of our QMLE agent. For instance, fundamental methods that can be trivially combined with QMLE include $N$-step returns and distributional learning, similarly to the critics in DMPO and D4PG. Certain methods, including double Q-learning (Hasselt, ; van Hasselt et al., ) and dueling networks (Wang et al., ) may not be directly applicable or relevant to QMLE, underscoring the importance of careful integration. We are particularly excited about using a cross-entropy classification loss in place of regression for training $Q$ approximators (Farebrother et al., ), as well as combining with ideas introduced by Li et al. (); Schwarzer et al. (). Moreover, formal explorations into the space of value mappings (van Seijen et al., ; Fatemi & Tavakoli, ), particularly those that benefit $Q$-function approximation with action-in architectures, offer an intriguing direction for future work.

Since our approach employs maximum likelihood estimation (MLE) in a disentangled manner (see discussions in Section 3.2), it makes it trivial to incorporate advances from supervised learning for training the parametric $\operatorname*{arg\,max}$ predictors. To provide an example, advancements in heteroscedastic uncertainty estimation, such that introduced by Seitzer et al. (), can be readily applied to model state-conditional variances for Gaussian $\operatorname*{arg\,max}$ predictors.

### D.2 Multiagent reinforcement learning via CTDE

Figure: Figure 8: Comparison of QMLE with linear value decomposition in a continuous variant of the “climbing” game with two agents (Claus & Boutilier, ). Linear value decomposition leads to a suboptimal reward of 5 due its limited representational capacity ($Q\doteq U1+U2$), whereas QMLE, by modeling the joint $Q$-function without such constraints, enables decentralized $\operatorname*{arg\,max}$ predictors that guide agents to the globally optimal reward of 11.
Refer to caption: x8.png

A problem scenario that could benefit from QMLE, and more broadly our framework, is multiagent reinforcement learning (MARL) under centralized training with decentralized execution (CTDE; Foerster et al., ; Lowe et al., ). Currently, the dominant class of solutions in this paradigm is based on combinations of deep Q-learning and value decomposition methods (Sunehag et al., ; Rashid et al., ). These approaches decompose the $Q$-function into local utilities for each agent, aiming for the local $\operatorname*{arg\,max}$ to correspond to the global $\operatorname*{arg\,max}$ on the joint $Q$-function. However, maintaining this alignment requires imposing structural constraints that limit the representational capacity of the joint $Q$-approximator, which can lead to suboptimal decentralized $\operatorname*{arg\,max}$ policies.

QMLE avoids these constraints by disentangling the process of approximating the joint $Q$-function from learning the decentralized $\operatorname*{arg\,max}$ policies, allowing for a universal representational capacity of the joint $Q$-function while maintaining decentralized execution. Instead of relying on a factored $Q$ approximation, QMLE models the joint $Q$-function in an unconstrained manner. Simultaneously, an $\operatorname*{arg\,max}$ predictor (or an ensemble of them) is separately trained for each agent, conditioned on their respective observations. This approach allows for improved coordination between agents by preserving the full representational capacity of the joint $Q$-function. As demonstrated in Figure 8, in a continuous variant of the “climbing” game (Claus & Boutilier, ), linear value decomposition (Sunehag et al., ) leads to a suboptimal reward of 5 due to its constrained capacity to represent the joint $Q$-function as $Q\doteq U1+U2$. In contrast, QMLE, by accurately modeling the joint $Q$-function, enables decentralized $\operatorname*{arg\,max}$ predictors that guide agents to the globally optimal reward of 11.

### D.3 Curriculum shaping through growing action spaces

Growing of the action space as a form of curriculum shaping is an effective approach for improving learning performance in complex problems. Nonetheless, existing approaches, such as that presented by Farquhar et al. (), are restricted to discrete actions. Seyde et al. () report improvements in sample efficiency and solution smoothness on physical control tasks by adaptively increasing the granularity of discretization during training. This is because coarse action discretizations can provide exploration benefits and yield lower variance updates early in training, while finer control resolutions later on help reduce bias at convergence. However, due to the strict dependence of this approach on a class of action-out architectures (Tavakoli et al., ; Seyde et al., ), it cannot ultimately transition from coarse discretization to the original continuous action space.

On the other hand, QMLE can support learning with dynamically growing action spaces, including transitions from finite to continuous supports in continuous action problems. We show this capability in a preliminary experiment, where we start with a coarse bang-off-bang discretization and later shift to the original continuous action space (Figure 9). This capacity positions QMLE, and more broadly our framework, as a promising candidate for future research in the context of growing action spaces.

Figure: Figure 9: Learning curves for discrete, continuous, and discrete-to-continuous (“curriculum”) variants of QMLE. Dashed lines mark the transition from discrete to continuous actions for the curriculum-based agents.
Refer to caption: x9.png

## Peer Reviews

confidence: 4
contribution: 3
initial_rating: 5
presentation: 3
questions: - What are the key theoretical assumptions underlying the QMLE framework, and how do they compare to traditional action-value methods?
- How does the QMLE framework perform in environments outside the DeepMind Control Suite? Are there specific tasks where its advantages or limitations become more pronounced?
- What guidelines can be provided for selecting hyperparameters when using the QMLE framework, and how does their choice impact performance across different environments?
- Can you elaborate on the implementation challenges encountered when applying the QMLE framework in practice? Were there any unexpected behaviors observed during training?
- How does the QMLE framework stack up against other recent approaches in reinforcement learning, particularly those utilizing action-value methods? Are there specific scenarios where it outperforms others?
- What are the authors’ thoughts on potential extensions or modifications to the QMLE framework that could enhance its applicability or efficiency in more complex scenarios?
- How robust is the QMLE approach to noise and variability in the environment? Have any experiments been conducted to assess its stability under such conditions?
soundness: 3
strengths: - The paper presents a novel perspective by challenging the conventional wisdom that policy gradient methods are inherently superior for complex action spaces, opening up new avenues for research and exploration.
- The introduction of the Q-learning with Maximum Likelihood Estimation (QMLE) framework effectively integrates principles traditionally associated with policy gradients into action-value learning, showcasing versatility and adaptability.
- The authors provide robust empirical results demonstrating that QMLE can achieve performance comparable to policy gradient methods on complex tasks, specifically in the DeepMind Control Suite, thereby validating their theoretical claims.
- The paper emphasizes the scalability of the proposed methods, which is crucial for real-world applications involving high-dimensional action spaces, making it a practical contribution to the field of reinforcement learning.
- By revealing that the strengths of policy gradient methods can be replicated in action-value approaches, the paper encourages a reevaluation of existing strategies in reinforcement learning, potentially influencing future research directions and methodologies.
summary: The paper challenges the conventional belief that policy gradient methods are superior to action-value methods for complex action spaces. The authors propose that this advantage comes from universal principles that can also be applied to action-value methods, such as using Monte Carlo approximations, amortized maximization, and scalable architectures. They introduce Q-learning with Maximum Likelihood Estimation (QMLE), a framework that adapts these principles to action-value learning. Empirical results show that QMLE performs comparably to policy gradient methods on complex action spaces, particularly on the DeepMind Control Suite. The findings suggest that the strengths of policy gradient methods are not intrinsic but can be replicated within action-value approaches.
weaknesses: - While the paper introduces the QMLE framework, it lacks in-depth theoretical analysis or proof of convergence properties, which could strengthen the foundational understanding of the proposed method.
- The empirical evaluations are primarily conducted in the DeepMind Control Suite, which may not fully represent the challenges and complexities found in more diverse real-world environments, limiting the generalizability of the findings.
- The paper could benefit from a more thorough comparison with other state-of-the-art action-value methods beyond policy gradient approaches to provide a clearer context for the advantages and limitations of the QMLE framework.
- There is little discussion on the sensitivity of the QMLE approach to hyperparameters, which can significantly impact performance in practice; this omission could hinder practitioners from effectively applying the method.
- The paper does not offer concrete suggestions for future research directions or improvements to the QMLE framework, which could leave readers uncertain about the next steps for advancing this line of inquiry.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 1
questions: 1. What are the limitations of policy gradients that lead to their replacement?
2. Why does the number of seeds vary across different tasks? Additionally, what do the shaded regions in the figures represent?
soundness: 2
strengths: 1. The identification of the three core principles is noteworthy and has the potential to influence future research on policy gradient methods, even considering that the paper's goal is to provide alternatives to traditional policy gradients. 
2. The experimental setup appears sound, with comparisons against several baselines across multiple seeds, and the results generally favor the proposed method. However, I would suggest including an ablation study (see Point 3 below).
summary: This paper challenges the assumption that policy gradient methods are inherently superior for environments with complex/continuous action spaces. The authors identify core principles (Monte Carlo approximations, maximum likelihood estimation, and action-in architectures) in policy gradients and incorporate them into action-value methods. Their method achieves comparable performance to policy gradient methods in continuous control tasks in DMC, demonstrating that action-value methods can handle complex action spaces without the need for policy gradients​
weaknesses: 1. My major concern is with the overall goal of the paper, as its central premise is unclear to me. First, what is the issue with policy gradients that the authors are aiming to replace them? This should have been clarified to justify the need for an alternative approach. If the goal is to develop a method that is simpler (i.e., fewer components, reduced computation, fewer hyperparameters) than policy gradients, similar to the approach in [1], I would argue that the proposed method is in fact more complex than policy gradients. It introduces additional hyperparameters and design decisions. Furthermore, the method eventually requires a parametric component for predicting the argmax (Principle 2 in Section 4). In my view, this component functions as a type of policy, albeit in a somewhat convoluted and unintuitive way. Its inclusion seems to contradict the paper’s aim of eliminating the need for a policy and policy gradients. In fact, I would argue that the proposed method cannot be considered purely as an action-value method, as claimed by the authors.

2. The argument regarding the equivalence of policy gradients and MLE (Section 3.2), while likely correct, is presented in a very informal manner. A more rigorous analysis or formal proof of this equivalence would significantly strengthen the paper.

3. The paper lacks an ablation study on the different components of the proposed method (Principles 1, 2, and 3). Given the number of design choices involved, an ablation study is essential to better understand the contribution of each principle.

4. Many of the equations in the paper (Equations 3, 4, 8, 9, 10, 11, 13, 14) are written without an equal sign, making them appear as disconnected mathematical expressions. While their meaning can be inferred from the surrounding text, the lack of clarity in some cases creates an informal mathematical tone and makes it difficult to interpret the exact role of these equations.

5. The background section spans three pages and covers material likely familiar to most readers. I recommend condensing this section and moving some of the content to the appendix. This would allow for a more detailed presentation of the algorithm (currently in Appendix A) in the main body of the paper, as well as addressing the concerns I raised above.


[1] Seyde, Tim, et al. "Solving Continuous Control via Q-learning." The Eleventh International Conference on Learning Representations. 2023.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: 1, The proposed method uses log-likelihood gradient to train the argmax predictors.  Why not use the policy gradient directly to update the the ensemble of argmax predictors?
soundness: 2
strengths: 1, The proposed principles underlying the scalability of policy gradient methods are intriguing observations, and a careful analysis of the gap between the two paradigms is insightful.

2, The presentation of the ideas proposed is clear.

3, Experiments were conducted across multiple domains, although without significant improvement.
summary: This paper proposes three universal principles from policy gradient methods and incorporates them into action-value framework.

The method is evaluated in DMC domains with continuous action space.

However, the proposed method does not show a significant improvement in performance over DDPG or D4PG, especially in domains with high-dimensional action spaces.
weaknesses: 1, There is no theoretical guarantees for computing the maximization in A_m instead of A(eq.17).    (In policy gradient methods, using an MC estimator in place of exact summation or integration has theoretical foundations.)  

2, The proposed method trains all the predictors from historical argmax approximation  to construct a small action space A_m for computing an approximation of best action. The iterative dependency restricted the actions to a subset where most actions are similar, potentially leading to a suboptimal solution.

3, As illustrated in Figure.2, QMLE can transcend DPG through a uniform sampling over action space([global]). But in high-dimensional action space, uniform sampling is usually inefficient. This paper lacks an ablation study of the uniform sampling and the ensemble of argmax predictors in the domains with high-dimensional action spaces.

Meta-review: The paper aims to identify why policy-based methods have seemed to outperform value-based ones in large action spaces and to use this insight to improve value-based RL. The motivation and writing are generally good, with some exception regarding theoretical and mathematical rigor. Reviewers raised a myriad other concerns, including regarding evaluation (choice of domains and ablations), hyperparameter sensitivity, and paper organization, which were largely addressed by the authors. However, reviewers remain skeptical of the significance of the paper.

Decision: Reject