Year: 2020

Abstract:
Controlling the movements of highly articulated agents and robots has been a long-standing challenge to model-free deep reinforcement learning. In this paper, we propose a simple, yet general, framework for improving the performance of policy gradient algorithms by discretizing the continuous action space. Instead of using a fixed set of predetermined atomic actions, we exploit particle filtering to adaptively discretize actions during training and track the posterior policy represented as a mixture distribution. The resulting policy can replace the original continuous policy of any given policy gradient algorithm without changing its underlying model architecture. We demonstrate the applicability of our approach to state-of-the-art on-policy and off-policy baselines in challenging control tasks. Baselines using our particle-based policies achieve better final performance and speed of convergence as compared to corresponding continuous implementations and implementations that rely on fixed discretization schemes.

heading: 1 INTRODUCTION
text: In the last few years, impressive results have been obtained by deep reinforcement learning (DRL) both on physical and simulated articulated agents for a wide range of motor tasks that involve learning controls in high-dimensional continuous action spaces (Lillicrap et al., 2015; Levine et al., 2016; Heess et al., 2017; Haarnoja et al., 2018c; Rajeswaran et al., 2018; Tan et al., 2018; Peng et al., 2018; 2020). Many methods have been proposed that can improve the performance of DRL for continuous control problems, e.g. distributed training (Mnih et al., 2016; Espeholt et al., 2018), hierarchical learning (Daniel et al., 2012; Haarnoja et al., 2018a), and maximum entropy regularization (Haarnoja et al., 2017; Liu et al., 2017; Haarnoja et al., 2018b). Most of such works, though, focus on learning mechanisms to boost performance beyond the basic distribution that defines the action policy, where a Gaussian-based policy or that with a squashing function is the most common choice as the basic policy to deal with continuous action spaces. However, the unimodal form of Gaussian distributions could experience difficulties when facing a multi-modal reward landscape during optimization and prematurely commit to suboptimal actions (Daniel et al., 2012; Haarnoja et al., 2017).
To address the unimodality issue of Gaussian policies, people have been exploring more expressive distributions than Gaussians, with a simple solution being to discretize the action space and use categorical distributions as multi-modal action policies (Andrychowicz et al., 2020; Jaśkowski et al., 2018; Tang & Agrawal, 2019). However, categorical distributions cannot be directly extended to many off-policy frameworks as their sampling process is not reparameterizable. Importantly, the performance of the action space discretization depends a lot on the choice of discrete atomic actions, which are usually picked uniformly due to lack of prior knowledge. On the surface, increasing the resolution of the discretized action space can make fine control more possible. However, in practice, this can be detrimental to the optimization during training, since the policy gradient variance increases with increasing number of atomic actions (Tang & Agrawal, 2019).
Our work also focuses on action policies defined by an expressive, multimodal distribution. Instead of selecting fixed samples from the continuous action space, though, we exploit a particlebased approach to sample the action space dynamically during training and track the policy represented as a mixture distribution with state-independent components. We refer to the resulting policy network as Particle Filtering Policy Network (PFPN). We evaluate PFPN on state-of-the-art on-policy and off-policy baselines using high-dimensional tasks from the PyBullet Roboschool en-
vironments (Coumans & Bai, 2016–2019) and the more challenging DeepMimic framework (Peng et al., 2018). Our experiments show that baselines using PFPN exhibit better overall performance and/or speed of convergence and lead to more robust agent control. as compared to uniform discretization and to corresponding implementations with Gaussian policies.
Main Contributions. Overall, we make the following contributions. We propose PFPN as a general framework for providing expressive action policies dealing with continuous action spaces. PFPN uses state-independent particles to represent atomic actions and optimizes their placement to meet the fine control demand of continuous control problems. We introduce a reparameterization trick that allows PFPN to be applicable to both on-policy and off-policy policy gradient methods. PFPN outperforms unimodal Gaussian policies and the uniform discretization scheme, and is more sampleefficient and stable across different training trials. In addition, it leads to high quality motion and generates controls that are more robust to external perturbations. Our work does not change the underlying model architecture or learning mechanisms of policy gradient algorithms and thus can be applied to most commonly used policy gradient algorithms.

heading: 2 BACKGROUND
text: We consider a standard reinforcement learning setup where given a time horizonH and the trajectory τ = (s1,a1, · · · , sH ,aH) obtained by a transient modelM(st+1|st,at) and a parameterized action policy πθ(at|st), with st ∈ Rn and at ∈ Rm denoting the state and action taken at time step t, respectively, the goal of learning is to optimize θ that maximize the cumulative reward:
J(θ) = Eτ∼pθ(τ) [rt(τ)] = ∫ pθ(τ)r(τ)dτ. (1)
Here, pθ(τ) denotes the state-action visitation distribution for the trajectory τ induced by the transient model M and the action policy πθ with parameter θ, and r(τ) = ∑ t r(st,at) where r(st,at) ∈ R is the reward received at time step t. We can maximize J(θ) by adjusting the policy parameters θ through the gradient ascent method, where the gradient of the expected reward can be determined according to the policy gradient theorem (Sutton et al., 2000), i.e.
∇θJ(θ) = Eτ∼πθ(·|st) [At∇θ log πθ(at|st)|st] . (2) whereAt ∈ R denotes an estimate to the reward term rt(τ). In DRL, the estimator ofAt often relies on a separate network (critic) that is updated in tandem with the policy network (actor). This gives rise to a family of policy gradient algorithms known as actor-critic.
On-Policy and Off-Policy Actor-Critics. In on-policy learning, the update policy is also the behavior policy based on which a trajectory is obtained to estimate At. Common on-policy actor-critic algorithms include A3C (Mnih et al., 2016) and PPO (Schulman et al., 2017), and directly employ Equation 2 for optimization. In off-policy learning, the policy can be updated without the knowledge of a whole trajectory. This results in more sample efficient approaches as samples are reusable. While algorithms such as Retrace (Munos et al., 2016) and PCL (Nachum et al., 2017) rely on Equation 2, many off-policy algorithms exploit a critic network to estimate At given a state-action pair (Q- or soft Q-value). Common off-policy actor-critic methods include DDPG (Lillicrap et al., 2015), SAC (Haarnoja et al., 2018b;d) and their variants (Haarnoja et al., 2017; Fujimoto et al., 2018). These methods perform optimization to maximize a state-action value Q(st,at). In order to update the policy network with parameter θ, they require the action policy to be reparameterizable such that the sampled action at can be rewritten as a function differentiable to the parameter θ, and the optimization can be done through the gradient∇atQ(st,at)∇θat.
Policy Representation. Given a multi-dimensional continuous action space, the most common choice in current DRL baselines is to model the policy πθ as a multivariate Gaussian distribution with independent components for each action dimension (DDPG, SAC and their variants typically use Gaussian with a monotonic squashing function to stabilize the training). For simplicity, let us consider a simple case with a single action dimension and define the action policy as πθ(·|st) := N (µθ(st), σ2θ(st)). Then, we can obtain log πθ(at|st) ∝ −(at − µθ(st))2. Given a sampled action at and the estimate of cumulative rewards At, the optimization process based on the above expression can be imagined as that of shifting µ
θ (st) towards the direction of at ifAt is higher
than the expectation, or to the opposite direction if At is smaller. Such an approach, though, can easily converge to a suboptimal solution, if, for example, the reward landscape has a basis between the current location of µ
θ (st) and the optimal solution, or hard to be optimized if the reward land-
scape is symmetric around µ θ (st). These issues arise due to the fact that the Gaussian distribution is inherently unimodal, while the reward landscape could be multi-modal (Haarnoja et al., 2017). Similar problems also could occur in Q-value based optimization, like DDPG and SAC. We refer to Appendix F for further discussion about the limitations of unimodal Gaussian policies and the value of expressive multimodal policies.

heading: 3 PARTICLE FILTERING POLICY NETWORK
text: In this section, we describe our Particle Filtering Policy Network (PFPN) that addresses the unimodality issues from which typical Gaussian-based policy networks suffer. Our approach represents the action policy as a mixture distribution obtained by adaptively discretizing the action space using state-independent particles, each capturing a Gaussian distribution. The policy network, instead of directly generating actions, it is tasked with choosing particles, while the final actions are obtained by sampling from the selected particles.

heading: 3.1 PARTICLE-BASED ACTION POLICY
text: Generally, we define P := {〈µi,k, wi,k(st|θ)〉|i = 1, · · · , n; k = 1, · · · ,m} as a weighted set of particles for continuous control problems with a m-dimension action space and n particles distributed on each action space, where µi,k ∈ R representing an atomic action location on the kth dimension of the action space, and wi,k(st|θ), satisfying ∑ i wi,k(st|θ) = 1, denotes the associated weight generated by the policy network with parameter θ given the input state st. Let pi,k(ai,k|µi,k, ξi,k) denote the probability density function of the distribution defined by the location µi,k and a noise process ξi,k. Given P , we define the action policy as factorized across the action dimensions:
πPθ (at|st) = ∏ k ∑ i wi,k(st|θ)pi,k(at,k|µi,k, ξi,k), (3)
where at = {at,1, · · · , at,m}, at,k ∈ R is the sampled action at the time step t for the action dimension k, and wi,k(·|θ) can be obtained by applying a softmax operation to the output neurons of the policy network for the k-th dimension. The state-independent parameter set, {µi,k}, gives us an adaptive discretization scheme that can be optimized during training. The choice of noise ξi,k relies on certain algorithms. It can be a scalar, e.g., the Ornstein–Uhlenbeck noise in DDPG (Lillicrap et al., 2015) or an independent sample drawn from the standard normal distribution N (0, 1) in soft Q-learning (Haarnoja et al., 2017), or be decided by a learnable variable, for example, a sample drawn fromN (0, ξ2i,k) with a learnable standard deviation ξi,k. In the later case, a particle become a Gaussian componentN (µi,k, ξ2i,k). Without loss of generality, we define the parameters of a particle as φi,k = [µi,k, ξi,k] for the following discussion.
While the softmax operation gives us a categorical distribution defined by w·,k(st|θ), the nature of the policy for each dimension is a mixture distribution with state-independent components defined by φi,k. The number of output neurons in PFPN increases linearly with the increase in the number of action dimensions and thus makes it suitable for high-dimensional control problems. Drawing samples from the mixture distribution can be done in two steps: first, based on the weights w·,k(st|θ), we perform sampling on the categorical distribution to choose a particle jk for each dimension k, i.e. jk(st) ∼ P (·|w·,k(st)); then, we can draw actions from the components represented by the chosen particles with noise as at,k ∼ pjk(st)(·|φjk(st)). Certain algorithms, like A3C and IMPALA, introduce differential entropy loss to encourage exploration. However, it may be infeasible to analytically evaluate the differential entropy of a mixture distribution without approximation (Huber et al., 2008). As such, we use the entropy of the categorical distribution if a differential entropy term is needed during optimization.
We refer to Appendix C for the action policy representation in DDPG and SAC where an invertible squashing function is applied to Gaussian components.

heading: 3.2 TRAINING
text: The proposed particle-based policy distribution is general and can be applied directly to any algorithm using the policy gradient method with Equation 2. To initialize the training, due to lack of prior knowledge, the particles can be distributed uniformly along the action dimensions with a standard deviation covering the gap between two successive particles. With no loss of generality, let us consider below only one action dimension and drop the subscript k. Then, at every training step, each particle i will move along its action dimension and be updated by
∇J(φi) = E [∑
t
ctwi(st|θ)∇φipi(at|φi)|st ]
(4)
where at ∼ πPθ (·|st) is the action chosen during sampling, and ct = At∑ j wj(st|θ)pj(at|φj)
is a coefficient shared by all particles on the same action dimension. Our approach focuses only on the action policy representation in general policy gradient methods. The estimation of At can be chosen as required by the underlying policy gradient method, e.g. the generalized advantage estimator (Schulman et al., 2015b) in PPO/DPPO and the V-trace based temporal difference error in IMPALA. Similarly, for the update of the policy neural network, we have
∇J(θ) = E [∑
t
ctpi(at|φi)∇θwi(st|θ)|st ] . (5)
From the above equations, although sampling is performed on only one particle for each given dimension, all of that dimension’s particles will be updated during each training iteration to move towards or away from the location of at according to At. The amount of the update, however, is regulated by the state-dependent weightwi(st|θ): particles that have small probabilities to be chosen for a given state st will be considered as uninteresting and be updated with a smaller step size or not be updated at all. On the other hand, the contribution of weights is limited by the distance between a particle and the sampled action: particles too far away from the sampled action would be considered as insignificant to merit any weight gain or loss. In summary, particles can converge to different optimal locations near them during training and be distributed multimodally according to the reward landscape defined by At, rather than collapsing to a unimodal, Gaussian-like distribution.

heading: 3.3 RESAMPLING
text: Similar to traditional particle filtering approaches, our approach would encounter the problem of degeneracy (Kong et al., 1994). During training, a particle placed near a location at which sampling gives a low At value would achieve a weight decrease. Once the associated weight reaches near zero, the particle will not be updated anymore (cf. Equation 4) and become ‘dead’. We adapt the idea of importance resampling from the particle filtering literature (Doucet et al., 2001) to perform resampling for dead particles and reactivate them by duplicating alive target particles.
We consider a particle dead if its maximum weight over all possible states is too small, i.e. maxst wi(st|θ) < , where is a small positive threshold number. In practice, we cannot check wi(st|θ) for all possible states, but can keep tracking it during sampling based on the observed states collected in the last batch of environment steps. A target particle τi is drawn for each dead particle i independently from the categorical distribution based on the particle’s average weight over the observed samples: τi ∼ P (·|Est [wk(st|θ)] , k = 1, 2, · · · ). Theorem 1. Let Dτ be a set of dead particles sharing the same target particle τ . Let also the logits for the weight of each particle k be generated by a fully-connected layer with parameters ωk for the weight and bk for the bias. The policy πPθ (at|st) is guaranteed to remain unchanged after resampling via duplicating φi ← φτ ,∀i ∈ Dτ , if the weight and bias used to generate the unnormalized logits of the target particle are shared with those of the dead one as follows:
ωi ← ωτ ; bi, bτ ← bτ − log (|Dτ |+ 1) . (6) Proof. See Appendix B for the inference.
Theorem 1 guarantees the correctness of our resampling process as it keep the action policy πPθ (at|st) identical before and after resampling. If, however, two particles are exactly the same
after resampling, they will always be updated together at the same pace during training and lose diversity. To address this issue, we add some regularization noise to the mean value when performing resampling, i.e. µi ← µτ + εi, where εi is a small random number to prevent µi from being too close to its target µτ .

heading: 3.4 REPARAMETERIZATION TRICK
text: The two-step sampling method described in Section 3.1 is non-reparameterizable, because of the standard way of sampling from the categorical distribution through which Gaussians are mixed. To address this issue and enable the proposed action policy applicable in state-action value based offpolicy algorithms, we consider the concrete distribution (Jang et al., 2016; Maddison et al., 2016) that generates a reparameterized continuous approximation to a categorical distribution. We refer to Appendix D for a formal definition of concrete distribution defined as CONCRETE below.
Let x(st|θ) ∼ CONCRETE({wi(st|θ); i = 1, 2, · · · }, 1), where x(st|θ) = {xi(st|θ); i = 1, 2, · · · } is a is a reparametrizable sampling result of a relaxed version of the one-hot categorical distribution supported by the probability of {wi(st|θ); i = 1, 2, · · · }. We apply the Gumbel-softmax trick (Jang et al., 2017) to get a sampled action value as
a′(st) = STOP (∑ i aiδ(i, arg maxx(st|θ)) )
(7)
where ai is the sample drawn from the distribution represented by the particle i with parameter φi, STOP(·) is a “gradient stop” operation, and δ(·, ·) denotes the Kronecker delta function. Then, the reparameterized sampling result can be written as follows:
aPθ (st) = ∑ i (ai − a′(st))mi + a′(st)δ(i, arg maxx) ≡ a′(st), (8)
where mi := xi(st|θ) + STOP(δ(i, arg maxx(st|θ)) − xi(st|θ)) ≡ δ(i, arg maxx(st|θ)) composing a one-hot vector that approximates the samples drawn from the corresponding categorical distribution. Since xi(st|θ) drawn from the concrete distribution is differentiable to the parameter θ, the gradient of the reparameterized action sample can be obtained by
∇θaPθ (st) = ∑ i (ai − a′(st))∇θxi(st|θ);∇φiaPθ = δ(i, arg maxx(st|θ))∇φiai. (9)
Through these equations, both the policy network parameter θ and the particle parameters φi can be updated by backpropagation through the sampled action a′(st).

heading: 4 RELATED WORK
text: Our approach focuses on the action policy representation exploiting a more expressive distribution other than Gaussians for continuous control problem in DRL using policy gradient method. In onpolicy gradient methods, action space discretization using a categorical distribution to replace the original, continuous one has been successfully applied in some control tasks (Andrychowicz et al., 2020; Tang & Agrawal, 2019). All of these works discretize the action space uniformly and convert the action space to a discrete one before training. While impressive results have been obtained that allow for better performance, such a uniform discretization scheme heavily relies on the number of discretized atomic actions to find a good solution. On the other hand, discretized action spaces cannot be directly applied on many off-policy policy gradient methods, since categorical distributions are non-reparameterizable. While DQN-like approaches are efficient for problems with discrete action spaces, such techniques without policy networks cannot scale well to high-dimensional continuous action spaces due to the curse of dimensionality (Lillicrap et al., 2015). Recent work attempted to solve this issue by using a sequential model, at the expense, though, of increasing the complexity of the state space (Metz et al., 2017). Chou et al. (2017) proposed to use beta distributions as a replacement to Gaussians. However, results from Tang & Agrawal (2018a) show that beta distributions do not work well as Gaussians in high-dimensional tasks.
Our PFPN approach adopts a mixture distribution as the action policy, which becomes a mixture of Gaussians when a learnable standard deviation variable is introduced to generate a normal noise
for sampling. It uses state-independent particles having state-dependent weights to track the policy distribution. While an early version of SAC also employed a mixture of Gaussians, such a mixture is completely state dependent, and hence it cannot provide a discretization scheme that is consistent globally for all given states. In addition, the components in the fully state-dependent mixture of Gaussians could collapse, resulting in similar issues as unimodal Gaussian policies (Tang & Agrawal, 2018a). Adopting state-independent components can reduce the network size and still provide expressive action policies when sufficient components are employed.
PFPN focuses on the policy distribution representation generated directly by the policy network without changing the underlying policy gradient algorithms or remodeling the problem, and thus it can be applied directly to most common used policy gradient methods in DRL. It is also complementary to recent works that focus on improving the expressiveness of the action policy through normalizing flows (Haarnoja et al., 2018a; Tang & Agrawal, 2018b; Mazoure et al., 2019; Delalleau et al., 2019), where the mixture distribution provided by PFPN can be employed as a base distribution. Other techniques applicable to policy gradient methods with a generally defined basic action policy can be combined with PFPN as well, such as the use of ordinal architecture for action parameterization (Tang & Agrawal, 2019), action space momentum as in the recent PPOCMA (Hämäläinen et al., 2018), and energy-based policy distribution optimization methods, like PGQL (O’Donoghue et al., 2016), Soft-Q learning (Haarnoja et al., 2017), SVPG (Liu et al., 2017), and policy optimization using Wasserstein Gradient Flows (Zhang et al., 2018).

heading: 5 EXPERIMENTS
text: The goal of our experiments is to evaluate whether existing policy gradient algorithms using PFPN can outperform the corresponding implementations with Gaussian policies, along with comparing our adaptive action discretization scheme generated by PFPN to the fixed, uniform one. For our comparisons, we use the set of particles as a mixture of Gaussians with learnable standard deviation. We run benchmarks on a range of continuous torque-based control tasks from PyBullet Roboschool environments (Schulman et al., 2015a). We also consider several challenging position-control tasks from the DeepMimic framework (Peng et al., 2018) where a 36-dimension humanoid agent learns a locomotion policy based on motion capture data with a 197-dimension state space.

heading: 5.1 COMPARISONS
text: Figure 1 and 2 evaluate our approach on two representative policy gradient methods: PPO/DPPO (Schulman et al., 2017; Heess et al., 2017), which is a stable on-policy method that exhibits good performance, and SAC (Haarnoja et al., 2018d), an off-policy method that achieves state-of-the-art performance in many tasks. The figures show the learning curve by cumulative rewards of evaluation rollouts during training. We also compare PFPN to the fixed discretization scheme (DISCRETE) obtained by uniformly discretizing each action dimension into a fixed number of bins and sampling actions from a categorical distribution. In all comparisons, PFPN and DISCRETE exploit the same number of atomic actions, i.e., number of particles in PFPN and number of bins in DISCRETE. We train five trials of each baseline with different random seeds that are the same across PFPN and the corresponding implementations of other methods. Evaluation was performed ten times every 1,000 training steps using deterministic action.
As it can be seen in Figure 1, PFPN outperforms Gaussian policies and DISCRETE in all of these tested tasks. Compared to Gaussian policies, our particle-based scheme achieves better final performance and typically exhibits faster convergence while being more stable across multiple trials. In the Roboschool tasks, DISCRETE performs better than the Gaussian policies. However, this doesn’t translate to the DeepMimic tasks where fine control demand is needed to reach DeepMimic’s multimodal reward landscape, with DISCRETE showing high variance and an asymptotic performance that is on par with or worse than Gaussian-based policies. In contrast, PFPN is considerably faster and can reach stable performance that is higher than both Gaussian and DISCRETE policies.
In the SAC benchmarks shown in Figure 2, DISCRETE cannot be applied since the categorical distribution that it employs as the action policy is non-parameterizable. PFPN works by exploiting the reparameterization trick detailed in Section 3.4. Given the state-of-the-art performance of SAC, the PFPN version of SAC performs comparably to or better than the vanilla SAC baseline and has faster convergence in most of those tasks, which demonstrates the effectiveness of our proposed adaptive discretization scheme. In DeepMimic tasks, considering the computation cost of running stable PD controllers to determine the torque applied to each humanoid joint (Tan et al., 2011), PFPN can save hours of training time due to its sampling efficiency.
PFPN can be applied to currently popular policy-gradient DRL algorithms. We refer to Appendix H for additional benchmark results, as well as results obtained with A2C/A3C (Mnih et al., 2016), IMPALA (Espeholt et al., 2018), and DDPG (Lillicrap et al., 2015). In most of these benchmarks, PFPN outperforms the Gaussian baselines and DISCRETE scheme, and is more stable achieving similar performance across different training trials. In Appendix H.5, we also compare the performance in terms of wall clock time, highlighting the sampling efficiency of PFPN over Gaussian and DISCRETE when facing complex control tasks. See Appendix G for all hyperparameters.

heading: 5.2 ADAPTIVE DISCRETIZATION
text: Compared to Gaussian-based policy networks, DISCRETE can work quite well in many on-policy tasks, as has been shown in recent prior work (Tang & Agrawal, 2019). However, in the comparative evaluations outlined above, we showed that the adaptive discretization scheme that PFPN employs results in higher asymptotic performance and/or faster convergence as compared to the uniform discretization scheme. To gain a better understanding of the advantages of adaptive discretization
for learning motor tasks, Table 1 further compares the performance of PFPN and DISCRETE across different discretization resolutions (number of particles and number of bins, respectively). As it can be seen, PFPN performs better than DISCRETE for any given resolution.
Intuitively, increasing the resolution, and hence the number of atomic actions, helps both DISCRETE and PFPN. However, the more atomic actions employed the harder the optimization problem will be for both methods due to the increase of policy gradient variance (see Appendix D for theoretical analysis). This can also be verified empirically by the performance decrease in Roboschool tasks when transitioning from 10 to 150 particles. In the more complex DeepMimic tasks, using too few atomic actions can easily skip over optimal actions. Although performance improves when the action resolution increases from 5 to 10, DISCRETE cannot provide any stable training results as denoted by the high variance among different trials. In contrast, PFPN performs significantly better across all resolutions and can reach best performance using only 35 particles. And as the number of particles increases beyond 35, PFPN has only a slight decrease in performance. This is because the training of DeepMimic tasks was run long enough to ensure that it could reach a relatively stable final performance. We refer to Appendix I for the sensitivity analysis of PFPN with respect to the number of particles, where employing more atomic actions beyond the optimal number results in slower convergence but similar final performance.
DeepMimic tasks rely on stable PD controllers and exploit motion capture data to design the reward function, which is more subtle than the Roboschool reward functions that primarily measure performance based on the torque cost and agent moving speed. Given a certain clip of motion, the valid movement of a joint may be restrained in some small ranges, while the action space covers the entire movement range of that joint. This makes position-based control problems more sensitive to the placement of atomic actions, compared to Roboschool torque-based control tasks in which the effective actions (torques) may be distributed in a relatively wide range over the action space. While uniform discretization could place many atomic actions blindly in bad regions, PFPN optimizes the placement of atomic actions, providing a more effective discretization scheme that reaches better performance with fewer atomic actions. As an example, Figure 3 shows how particles evolve during training for one of the humanoid’s joints in the DeepMimicWalk task where PFPN reaches a cumulative imitation reward much higher than DISCRETE or Gaussian. We can see that the final active action spaces cover only some small parts of the entire action space. In Appendix H, we also show the particle evolution results for Roboschool’s AntBulletEnv-v0 task. Here, the active action spaces are distributed more uniformly across the entire action space, which explains why DISCRETE is able to exploit its atomic actions more efficiently than in DeepMimic tasks.

heading: 5.3 CONTROL QUALITY
text: To highlight the control performance of the adaptive discretization scheme, Figure 4 compares the motion generated by PFPN and DISCRETE in the DeepMimicWalk task. As can be seen in the figure, PFPN generates a stable motion sequence with a nature human-like gait, while DISCRETE is stuck at a suboptimal solution and generates a walking motion sequence with an antalgic-like gait where the agent walks forward mainly through the use of its left leg. From the motion trajectories,
it can also be seen that PFPN results in a more stable gait with a clear cyclic pattern strictly following the motion capture data. We also assess the robustness of the learned policies to external perturbations. Table 2 reports the minimal force needed to push the humanoid agent down. All experiments were performed af-
ter training using deterministic actions. It is evident that the PFPN agent can tolerate much higher forces than the Gaussian one. The fixed discretization in DISCRETE is less flexible, and as a result it cannot learn generalized features that will enable robust agent control. We also refer to Appendix H for additional results including motion trajectories obtained in the AntBulletEnv-v0 task, as well as the controls (torque profiles) of the corresponding ant agents.

heading: 6 CONCLUSION
text: We present a general framework for learning controls in high-dimensional continuous action spaces through particle-based adaptive discretization. Our approach uses a mixture distribution represented by a set of weighted particles to track the action policy using atomic actions during training. By introducing the reparameterization trick, the resulting particle-based policy can be adopted by both on-policy and off-policy policy gradient DRL algorithms. Our method does not change the underlying architecture or learning mechanism of the algorithms, and is applicable to common actor-critic policy gradient DRL algorithms. Overall, our particle filtering policy network combined with existing baselines leads to better performance and sampling efficiency as compared to corresponding implementations with Gaussian policies. As a way to discretize the action space, we show that our method is more friendly to policy gradient optimization by adaptive discretization, compared to uniform discretization, as it can optimize the placement of atomic actions and has the potential to meet the fine control requirement by exploiting fewer atomic actions. In addition, it leads to high quality motion and more robust agent control. While we currently track each action dimension independently, accounting for the synergy that exists between different joints has the potential to further improve performance and motion robustness, which opens an exciting avenue for future work.

heading: A ALGORITHM
text: Algorithm 1 Policy Gradient Method using Particle Filtering Policy Network Initialize the neural network parameter θ and learning rate α; initialize particle parameters φi to uniformly distribute particles on the action dimension; initialize the threshold to detect dead particles using a small number; initialize the value of interval n to perform resampling. loop
for each environment step do // Record the weight while sampling. at ∼ πθ,P(·|st) Wi ←Wi ∪ {wi(st|θ)} end for for each training step do
// Update parameters using SGD method. φi ← φi + α∇J(φi) θ ← θ + α∇J(θ)
end for for every n environment steps do
// Detect dead particles and set up target ones. for each particle i do
if maxwi∈Wi wi < then τi ∼ P (·|E [wk|wk ∈ Wk] , k = 1, 2, · · · ) T ← T ∪ {τi}; Dτi ← Dτi ∪ {i}
end if end for // Resampling. for each target particle τ ∈ T do
for each dead particle i ∈ Dτ do // Duplicate particles. φi ← φτ with µi ← µτ + εi // Duplicate parameters of the last layer in the policy network. ωi ← ωτ ; bi ← bτ − log(|Dτ |+ 1) end for bτ ← bτ − log(|Dτ |+ 1) Dτ ← ∅
end for T ← ∅;Wi ← ∅
end for end loop

heading: B POLICY NETWORK LOGITS CORRECTION DURING RESAMPLING
text: Theorem 1. Let Dτ be a set of dead particles sharing the same target particle τ . Let also the logits for the weight of each particle k be generated by a fully-connected layer with parameters ωk for the weight and bk for the bias. The policy πPθ (at|st) is guaranteed to remain unchanged after resampling via duplicating φi ← φτ ,∀i ∈ Dτ , if the weight and bias used to generate the unnormalized logits of the target particle are shared with those of the dead one as follows:
ωi ← ωτ ; bi, bτ ← bτ − log (|Dτ |+ 1) . (10) Proof. The weight for the i-th particle is achieved by softmax operation, which is applied to the unnormalized logits Li, i.e. the direct output of the policy network:
wi(st) = SOFTMAX(Li(st)) = eLi(st)∑ k e Lk(st) . (11)
Resampling via duplicating makes dead particles become identical to their target particle. Namely, particles in Dτ ∪ {τ} will share the same weights as well as the same value of logits, say L′τ , after
resampling. To ensure the policy identical before and after sampling, the following equation must be satisfied ∑
k eLk(st) = ∑ Dτ∪{τ} eL ′ τ (st) + ∑ k 6∈Dτ∪{τ} eLk(st) (12)
where Lk is the unnormalized logits for the k-th particle such that the weights for all particles who are not in Dτ ∪ {τ} unchanged, while particles in Dτ ∪ {τ} share the same weights. A target particle will not be tagged as dead at all, i.e. τ 6∈ Dk for any dead particle set Dk, since a target particle is drawn according to the particles’ weights and since dead particles are defined as the ones having too small or zero weight to be chosen. Hence, Equation 12 can be rewritten as∑
i∈Dτ
eLi(st) + eLτ (st) = (|Dτ |+ 1)eL ′ τ (st), (13)
Given that eLi(st) ≈ 0 for any dead particle i ∈ Dτ and that the number of particles is limited, it implies that
eLτ ≈ (|Dτ |+ 1)eL ′ τ (st). (14)
Taking the logarithm of both sides of the equation leads to that for all particles in Dτ ∪ {τ}, their new logits after resampling should satisfy L′τ (st) ≈ Lτ (st)− log(|Dτ |+ 1). (15) Assuming the input of the full-connected layer who generatesLi is x(st), i.e. Li(st) = ωix(st)+bi, we have
ω′ix(st) + b ′ i = ωτx(st) + bτ − log (|Dτ |+ 1) . (16)
Then, Theorem 1 can be reached.
If we perform random sampling not based on the weights during resampling (see Appendix I), it is possible to pick a dead particle as the target particle. In that case
L′τ (st) ≈ Lτ (st)− log(|Dτ |+ (1− ∑ k δ(τ,Dk))), (17)
whereL′τ (st) is the new logits shared by particles inDτ and δ(τ,Dk) is the Kronecker delta function δ(τ,Dk) = { 1 if τ ∈ Dk 0 otherwise (18)
that satisfies ∑ k δ(τ,Dk) ≤ 1. Then, for the particle τ , its new logits can be defined as
L′′τ (st) ≈ (1− ∑ k δ(τ,Dk))L′τ (st) + ∑ k δ(τ,Dk)Lτ . (19)
Consequently, the target particle τ may or may not share the same logits with those inDτ , depending on if it is tagged as dead or not.

heading: C POLICY REPRESENTATION WITH ACTION BOUNDS
text: In off-policy algorithms, like DDPG and SAC, an invertible squashing function, typically the hyperbolic tangent function, will be applied to enforce action bounds on samples drawn from Gaussian distributions, e.g. in SAC, the action is obtained by at(ε, st) = tanhut,k where ut,k ∼ N (µθ(st), σ2θ(st)), and µθ(st) and σ2θ(st)) are parameters generated by the policy network with parameter θ.
Let at = {tanhut,k} where ut,k, drawn from the distribution represented by a particle with parameter φt,k, is a random variable sampled to support the action on the k-th dimension. Then, the probability density function of PFPN represented by Equation 3 can be rewritten as
πPθ (at|st) = ∏ k ∑ i wi,k(st|θ)pi,k(ut,k|φi,k)/(1− tanh2 ut,k), (20)
and the log-probability function becomes log πPθ (at|st) = ∑ k log [∑ i wi,k(st|θ)pi,k(ut,k|φi,k)− 2 (log 2− ut,k − softplus(−2ut,k)) ] .
(21)

heading: D CONCRETE DISTRIBUTION
text: Concrete distribution was introduced by Maddison et al. (2016). It is also called Gumbel-Softmax and proposed by Jang et al. (2016) concurrently. Here, we directly give the definition of concrete random variables X ∼ CONCRETE(α, λ) by its density function using the notion from Maddison et al. (2016) as below:
pα,λ(x) = (n− 1)!λn−1 n∏ k=1
( αkx
−λ−1 k∑n
i=1 αix −λ i
) , (22)
where X ∈ {x ∈ Rn|xk ∈ [0, 1], ∑n k=1 xk = 1}, α = {α1, · · · , αn} ∈ (0,+∞)n is the location parameter and λ ∈ (0,+∞) is the temperature parameter. A sample X = {X1, · · · , Xn} can be drawn by
Xk = exp((logαk +Gk)/λ)∑n i=1 exp((logαi +Gi)/λ) , (23)
where Gk ∼ GUMBEL i.i.d., or more explicitly, Gk = − log(− logUk) with Uk drawn from UNIFORM(0, 1).
From Equation 23, X can be reparameterized using the parameter α and λ, and gives us a relaxed version of continuous approximation to the one-hot categorical distribution supported by the logits α. As λ is smaller, the approximation is more discrete and accurate. In all of our experiments, we pick λ = 1.
For convenience, in Section 3.4, we use CONCRETE with parameter w ∈ {w1, · · · , wn|wk ∈ [0, 1], ∑n k=1 wk = 1} as the probability weight to support a categorical distribution instead of the logits α. We can get α in terms of w by
αk = log(wk/(1− wk)). (24)
SinceX ∼ CONCRETE(α, λ) is a relaxed one-hot result, we use arg maxX to decide which particle to choose in the proposed reparameterization trick.
E VARIANCE OF POLICY GRADIENT IN PFPN CONFIGURATION
Since each action dimension is independent to others, without loss of generality, we here consider the action at with only one dimension along which n particles are distributed and the particle i to represent a Gaussian distribution N (µi, σ2i ). In order to make it easy for analysis, we set up the following assumptions: the reward estimation is constant, i.e. At ≡ A; logits to support the weights of particles are initialized equally, i.e. wi(st|θ) ≡ 1n for all particles i and ∇θw1(st|θ) = · · · = ∇θwn(st|θ); particles are initialized to equally cover the whole action space, i.e. µi = i−nn , σ2i ≈ 1n2 where i = 1, · · · , n. From Equation 5, the variance of the policy gradient under such assumptions is
V[∇θJ(θ)|at] = ∫ At∑i pi(at|µt,σt)∇θwi(st|θ)∑
i wi(st|θ)pi(at|µt,σt) a2tdat ∝∑i∇θwi(st|θ) ∫ a2tpi(at|µt, σt)dat ∝∼∑i(µ2i + σ2i )∇θwi(st|θ) ∝∑i (i−n)2+1n2 = n3 + 7 6n − 12
∼ 1− 32n +O( 1n2 ).
(25)
Given V[∇θJ(θ)|at] = 0 when n = 1, from Equation 25, for any n > 0, the variance of policy gradient V[∇J(θ)|at] will increase with n. Though the assumptions usually are hard to meet perfectly in practice, this still gives us an insight that employing a large number of particles may result in more challenge to optimization.
This conclusion is consistent with that in the case of uniform discretization (Tang & Agrawal, 2019) where the variance of policy gradient is shown to satisfy
V[∇θJ(θ)|at]DISCRETE ∼ 1− 1
n . (26)
That is to say, in either PFPN or uniform discretization scheme, we cannot simply improve the control performance of the police by employing more atomic actions, i.e. by increasing the number of particles or using more bins in the uniform discretization scheme, since the gradient variance increases as the discretization resolution increases. However, PFPN has a slower increase rate, which implies that it might support more atomic actions before performance drops due to the difficulty in optimization. Additionally, compared to the fixed, uniform discretization scheme, atomic actions represented by particles in PFPN are movable and their distribution can be optimized. This means that PFPN has the potential to provide better discretization scheme using fewer atomic actions and thus be more friendly to optimization using policy gradient.

heading: F MULTI-MODAL POLICY
text: In this section, we show the multi-modal representation capacity of PFPN on special designed tasks.
One-step Bandit. This is a simple task with one dimension action space A = [−1, 1]. It has an asymmetric 2-peak reward landscape inversely proportional to the minimal distance to points−0.25 and 0.75, as the gray line shown in Figure 5(a). The goal of this task is to find out the optimal points close to−0.25 and 0.75. In Figure 5(a), we show the stochastic action sample distributions of PFPN and the naive Gaussian policy after training with the same number of iterations. It is clear that PFPN captures the bi-modal distribution of the reward landscape, while the Gaussian policy gives an unimodal distribution capturing only one of reward peaks.
2D Multi-goal Navigation. In this task, the reward landscape is designed symmetrically with four goal points at [±0.5,±0.5] and the agent has the task to reach any of the goal points. The cost (negative of the reward) function of the state S ∈ R2 and action A ∈ R2 is defined as the distance from the target position to the closet goal point. The naive Gaussian policy is initialized with mean value around the origin such that it is placed at the center point of the reward basin initially. Figure 5(b) shows the training performance curve and the one-step path trajectories given by PFPN and the Gaussian policy after training. While PFPN successfully learns diverse trajectories
reaching all four goals, the Gaussian policy fails to learn anything due to the symmetry of the reward landscape.
In the following, we limit our discussion to the expressivity of the basic action policy distributions generated directly by the policy network in actor-critic policy gradient methods, without the consideration of other methods to enhance the expressivity of action policies based on base ones, e.g. normalizing flows, or those to help better policy exploration by learning mechanisms, like entropybased policies.
For simplicity, let us consider a 1-dimension Gaussian policy with log-probability of
log πθ(at|st) = − (at − µθ(st))2
2σ2θ(st) − log σθ(st)− log 2π. (27)
where at ∼ N (µθ(st), σ2θ(st)). In order to update the policy network with parameter θ, we use Equation 2 with
∇θ log πθ(at|st) = ∇µθ(st) log πθ(at|st)∇θµθ(st) +∇σθ(st) log πθ(at|st)∇θσθ(st) (28) where
∇µθ(st) log πθ(at|st) = (at − µθ(st))
σ2θ(st) ;∇σθ(st) log πθ(at|st) = (at − µθ(st))2 − σ2θ(st) σ3θ(st) . (29)
The optimization of µθ(st) is along the direction of At(at − µθ(st)). Therefore, the optimization process is analogous to sliding µθ(st), the location of policy distribution, towards or opposite to the sampled action at regularized by the advantage estimation At. If At is higher than the average Et [At], the optimization will push µθ(st) towards to the location of at; if At is smaller than the average, µθ(st) will be pushed away from the direction of at − µθ(st). Regarding the update of σθ(st), σθ(st) will increase and make the distribution cover at if At is higher than the average and the distance between at and µθ(st) is out of the range of σθ(st); otherwise, σθ(st) will decrease and make the distribution shrink. Such an optimization strategy will encounter problems when, for example, facing a symmetric reward landscape defined by At, just like the 2D multi-goal navigation problem shown above. The Gaussian policy distribution in such a case would be optimized to move towards multiple directions simultaneously. This makes the policy distribution staying around its current location and unable to be optimized. Similarly, when facing an asymmetric, multimodal reward landscape as shown in the one-step bandit test case, the Gaussian policy would only be able to capture just one mode at best due to its unimodality.
Though in high-dimensional control problems, the reward landscape has a more complex shape, the multimodality is quite common in various, practical tasks. As an empirical proof, Figure 3 shows the evolution of the particle distributions during training, which captures the multimodality along different dimensions in DeepMimicWalk task. In such a task, Gaussian policy may face the problem of premature convergence and be stuck at suboptimal solutions because of its unimodality. Therefore, a multimodal policy distribution should be preferred for better capturing the reward landscape shape.
Fixed, uniform discretization (DISCRETE) schemes can also provide a multimodal policy represented by the categorical distribution. However, it is hard for DISCRETE to find an optimal solution due to the blindness of uniform discretization. Without loss of generality, we define the action space A as the range of [−1, 1] and assume that the action space is discretized with n bins. Under this setup, we will have atomic actions of {at,1, at,2, · · · , at,n} with a distance of 2n between two consecutive atomic actions. Let a∗t (st) be the optimal solution given the state st. We can measure the error between the optimal solution a∗t (st) and the best solution that DISCRETE could provide by
min k |a∗t (st)− at,k| ≤
1 n . (30)
This only gives us an upper bound of the minimal error as the half size of a bin. We can decrease the upper bound by exploiting more atomic actions. However, this cannot necessarily help decrease the lower bound. This analysis gives us an insight of the limitations that DISCRETE has.
Table 3 reports the lower bound of the minimum error that DISCRETE would achieve with varying number of bins. We can see that the best discretization scheme for DISCRETE is to use 4 bins.
However, in practice, we are usually unable to quantitatively analyze the lower bound error with respect to the number of bins in complex DRL tasks. Increasing, though, the number of bins would reduce the possible maximum error. For example, it is better to use 9 bins compared to the case with 7 or 5 bins, or better to use 10 bins compared to that using 8 or 6 bins. However, the policy gradient variance problem caused by introducing more atomic actions (See Appendix E) would influence the optimization negatively. To solve this dilemma, PFPN can optimize the placement of atomic actions during training and thus has the potential to meet the fine control requirement with fewer atomic actions.

heading: G HYPERPARAMETERS
text: Table 4 lists the default hyperparameters used in all of our experiments. Regarding PPO and A2C, in all Roboschool tasks except for the HumanoidBulletEnv-v0 one, we use a single worker thread; for HumanoidBulletEnv-v0 and DeepMimic tasks, we exploit the advantage of distributed training and use DPPO (synchronous PPO) and A3C (asynchronous A2C) with multiple worker threads, while IMPALA is natively multi-thread.

heading: H ADDITIONAL RESULTS
text: H.1 COMPARISON TO GAUSSIAN AND UNIFORM DISCRETIZATION POLICIES
Figure 6 compares baselines that employ Gaussian policies to their PFPN counterparts on a variety of Roboschool and DeepMimic tasks and the fixed, uniform discretization scheme (DISCRETE) with the same number of atomic actions. The results are obtained as discussed in Section 5.1, where ten evaluation trials run every 1,000 training steps using deterministic actions. PFPN outperforms Gaussian policies and fixed, uniform discretization scheme in those baselines and is more stable across different training trials.
To further highlight the value that particle-based discretization adds to the action exploration problem, we also compare the motion generated by a PFPN-PPO policy in the AntBulletEnv-v0 task to the ones obtained by vanilla PPO with Gaussian action policy and that using fixed, uniform discretization scheme. We project the one-episode motion trajectories of the four end effectors (feet) of the ant agent into two dimensions in Figure 7. As it can be seen, there is a significant difference in the motion taken by the three agents, with PFPN leading to higher performance as shown in Figure 7. Similarly to our analysis in Figure 4, Gaussian-based PPO and DISCRETE-PPO have more noise in the generated manifold, while PFPN-PPO performs robustly with a more clear cyclic
motion pattern. We also show the particle evolution of the ant agent during training in Figure 8, which reflects the optimization of particle distribution.
In Figure 9, we compare the torques generated by PFPN to those generated by Gaussian and DISCRETE. As it can been seen, PFPN generates significantly different torque profiles than the ones obtained by Gaussian both in terms of frequency and/or amplitude that result in higher asymptotic performance shown in Figure 6. PFPN has similar torque frequency and amplitude with DISCRETE, but also has significant difference in details, which leading to a better performance.
H.2 ADDITIONAL OFF-POLICY RESULTS
Besides the SAC benchmarks shown in Section 5.1, we test PFPN with DDPG, another popularly used off-policy algorithm, which runs policy gradient method only through state-action value. Differentiate the above experiments where each particle is assigned with a learnable variable and represents a Gaussian distribution, we follow the default configuration of DDPG and use a scalar noise during action sampling. DDPG provides relatively worse performance compared to SAC and cannot work well in HumanoidBulletEnv-v0 and DeepMimic tasks. As supplement, three environments, HalfCheetah-v2, Ant-v2 and Humanoid-v2, from OpenAI Gym benchmark suite are introduced in Figure 10. PFPN shows its advantage in most of those tasks.
H.3 COMPARISON TO GAUSSIAN POLICIES WITH BIG NETWORK
The policy network in PFPN has similar size with the one in DISCRETE. Therefore, the performance advantage of PFPN over DISCRETE clearly comes from its more flexible discretization scheme. Compared to the Gaussian baselines, PFPN exploits a relatively larger policy network, though the number of hidden neurons is the same. To demonstrate that the performance gain of PFPN is not due to its large network size, we increase the number of hidden neurons in Gaussian baselines such that they have similar number of policy network parameters with PFPN. The performance comparison between PFPN and the scaled up version of Gaussian baselines (Gaussian-Big) is shown in Table 5. Training is done after a fixed number of samples are collected as shown in Figure 1. As can be seen from the table, increasing the number of hidden neurons does not lead to any significant improvements in Gaussian policies, with PFPN still reaching better final performance.
H.4 COMPARISON TO FULLY STATE-DEPENDENT GAUSSIAN MIXTURE POLICIES
PFPN in our experiments employs a mixture of Gaussians with state-dependent weights but stateindependent components. The state-independent components can provide a global configuration of particle distributions that can be used as a discretization scheme. In theory, a fully state-dependent Gaussian mixture model (GMM) can also work as the action policy in DRL. However, in our experiments depicted in Figure 11, we found that GMM usually does not work quite well and even worse than Gaussians for complex continuous control problems. This is consistent with the results reported by Tang & Agrawal (2018a). As shown in Figure 11, GMM can only reach better performance than Gaussian in the AntBulletEnv-v0 task with PPO algorithm and in the HumanoidBulletEnv-v0 task using SAC, and is worse than PFPN in all tested benchmarks. GMM needs a much larger policy network as shown in Table 5. This may pose a challenge to optimization. Another issue of GMM
observed during our experiments is that GMM components are easy to collapse together and lose the advantage of multimodality. In the test cases of SAC, we use the reparameterization trick introduced in Section 3.4 to perform state-action value based optimization.
H.5 TIME COMPLEXITY
Sampling from categorical distributions directly or using Gumbel tricks (Papandreou & Yuille, 2011) is typically more expensive than that from Gaussians. In addition, both PFPN and DISCRETE need more time than the Gaussian baselines in order to perform action sampling and complete a training iteration due to their larger network sizes. Compared to DISCRETE, PFPN has higher time complexity as it needs an extra process of sampling from the Gaussian distributions represented by the particles. While the resampling process can cost time as well, in practice, it is only performed every tens of thousand interactions with the environment during training. Despite its higher time complexity, though, PFPN is more sample efficient than Gaussian baselines and DISCRETE, needing less actual clock time to reach better performance. To highlight this, Figure 12 reports the training performance as a function of running time (wall clock time). All training was done on machines having the same configuration with Nvidia Tesla V100 GPUs and stopped when a fixed number of samples was collected for training.
PFPN needs more time to leverage the same number of samples as Gaussian baselines. However, the performance obtained at a fixed time can be significantly higher as shown in Figure 12. Especially in DeepMimic tasks, the sampling efficiency of PFPN is quite apparent. In DeepMimicWalk using DPPO, PFPN needs about 6 hours to reach a cumulative reward of 500, while Gaussian baselines needs around 8 hours to obtain a similar score. The gap between PFPN and Gaussian baselines is more evident in SAC cases. As our SAC implementation used a single thread, it took much more time to finish the training compared to DPPO that worked distributedly. While PFPN and Gaussian baselines using SAC have almost the same final performance, PFPN converged about ten hours before the Gaussian baseline. Simulation in DeepMimic tasks is quite expensive in term of wall clock time, mainly due to the complexity of running stable PD controllers (Tan et al., 2011) and computing the reward by comparing the agent motion to the motion capture data. Once the simulated humanoid agent falls down (one of the termination conditions in the training of DeepMimic tasks), the simulation environment needs to reset and start a new environment episode. This process can take lots of time and poses a challenge to the algorithm’s ability to do better action space exploration at the initial stage of training. It is also the reason why DISCRETE needs more wall time than PFPN, even though its time complexity is lower.

heading: I SENSITIVITY ANALYSIS
text: Number of Particles. Since the particle configuration in PFPN is state-independent, it needs a sufficient number of particles to meet the fine control demand. Intuitively, employing more particles
will increase the resolution of the action space, and thus increase the control capacity and make fine control more possible. However, in Appendix E, we prove that due to the variance of policy gradient increasing as the number of particles increases, the more particles employed, the harder the optimization would be. Therefore, it may negatively influence the performance to employ too many particles. This conclusion is consistent with the benchmark results of Roboschool tasks shown in Table 1 as the final performance decreases while the number of particles increases. The DeepMimicWalk task with more than 35 particles, though reaching similar final performance, gets slower convergence as the number of particles increases. To clarify this, we show the learning curve of the DeepMimicWalk task with different number of particles in Figure 13(a), where PFPN-x represents the case that there are x particles per action dimension. As it can be seen, there is an obvious convergence delay as the number of particles per action dimension increases from 35 to 100. On the other hand, as we can see, a coarse discretization resolution employing too few particles, i.e., 5 or 10 particles per action dimension, will cause performance drops evidently, since the too few number of particles limits the control capacity.
Resampling Strategies. In Figure 13(b), We compare PFPN with default resampling strategy explained in Section 3.3 to a random resampling strategy (red) and that without resampling (green). The default resampling strategy is to draw targets for dead particles according to the weights of remaining alive ones. The random resampling strategy is to draw targets randomly from remaining alive particles. It can be seen that reactivating dead particles by resampling could help improve the training performance. Even the random resampling, though probably reactivating dead particles and place them on suboptimal locations, it still leads to better performance by keeping exploiting more effective particles, compared to the case without resampling. However, random resampling could lead to high variance and make the training process unstable by introducing too much uncertainty.
Figure 14 further compares PFPN’s resampling strategy to no resampling for Roboschool and DeepMimic environments. As can be seen, in the more challenging DeepMimic tasks, our resampling strategy leads to an obvious improvement (note that 600 is the best reward that an algorithm can achieve). As compared to position-based DeepMimic control tasks, Roboschool agents directly learn torque-based controls where the effective atomic action space is uniformly distributed across the specified joint torque limits (see Section 5.2 for details). Taking also into account that PFPN requires only 10 atomic actions per dimension in the Roboschool tasks, particles are less likely to become degenerate since each of them will possibly become active at a certain observed state during training. While employing more particles would trigger the resampling process, this could lead to worse performance because of the increased difficulty in optimization (See Appendix E).
Resampling Hyperparameters. We also analyze the sensitivity of PFPN to the resampling hyperparameters: the resampling threshold , which determines whether a particle is dead or not, and the resampling interval, which denotes how often the resampling is performed and is measured by environment episodes. Results in Figure 13(c) and 13(d) show that the resampling process itself is robust and not very sensitive to these two hyperparameters. However, an extremely small value of
resampling threshold or large value of resampling interval still would hurt the performance by preventing resampling and push the learning curves towards to the case of PFPN without resampling. On the other hand, a too large resampling threshold will lead alive particles to being labeled as dead, increasing the variance of the training performance. Resampling with a too small interval will incur resampling before sufficient action exploration and thus cause the same problem with a too large value of resampling interval. In our tests, we choose 20 environment episodes as the default resampling interval, and a dynamic value of resampling threshold depending on the number of particles that each action dimension has, which is around 0.0015 in DeepMimic tasks with 35 particles per action dimension.

Review summaries:
This paper presents an approach to multimodal policies based on Gaussian mixtures. The policy is parameterized as a set of Gaussian distributions (with state-invariant mean and variance) weighted by state-dependent mixture weights, which are the output of a (softmaxed) network. The weighting network and the means and covariances of the Gaussians are updated with standard RL losses. The authors propose a resampling scheme for mixture elements that consistently have low weight, in the style of resampling in particle filters. The authors evaluate the method with several RL algorithms including PPO and SAC, and on a variety of environments. 

In the paper "Adaptive Discretization for Continuous Control using Particle Filtering Policy Network", the authors introduce a new way to discretise the action space of agent in RL settings by using a Particule Filtering approach. The main idea is that the learned policy will output the weight of each particle to define which one should be used, while the position of the particle changes during the learning process. Particles that are not moved (because they have a weight that is systematically too low) are removed and resampled from other particles.