C OMPETITIVE EXPERIENCE REPLAY
A BSTRACT
Deep learning has achieved remarkable successes in solving challenging reinforcement learning (RL) problems.
However, it still often suffers from the need to engineer a reward function that not only reﬂects the task but is also carefully shaped.
This limits the applicability of RL in the real world.
It is therefore of great practical importance to develop algorithms which can learn from unshaped, sparse reward signals, e g. a binary signal indicating successful task completion.
We propose a novel method called competitive experience replay, which efﬁciently supplements a sparse reward by placing learning in the context of an exploration competition between a pair of agents.
Our method complements the recently proposed hindsight experience replay (HER) by inducing an automatic exploratory curriculum.
We evaluate our approach on the tasks of reaching various goal locations in an ant maze and manipulating objects with a robotic arm.
Each task provides only binary rewards indicating whether or not the goal is completed.
Our method asymmetrically augments these sparse rewards for a pair of agents each learning the same task, creating a competitive game designed to drive exploration.
Extensive experiments demonstrate that this method leads to faster converge and improved task performance
I NTRODUCTION
Reinforcement learning (RL) combined with neural networks has recently led to a wide range of successes in learning policies for sequential decision-making problems.
This includes simulated environments, such as playing video games (Mnih et al., 2013; 2016), defeating the best human player at the game of Go (Silver et al., 2016; 2017b;a), high dimensional continuous control (Schulman et al., 2016; 2017; 2015), as well as robotic control (Chebotar et al., 2017;
Levine et al., 2016; Andrychowicz et al., 2018).
Despite these successes, a key challenge, especially for robotics, is the need to engineer a reward function that not only reﬂects the task at hand but is also carefully shaped to guide the policy optimization (see e.g.
Popov et al.
2017, Ng et al. 2006).
For example, Popov et al.
(2017) use a cost function consisting of ﬁve terms which need to be carefully weighted in order to train a policy for stacking a brick on top of another one.
The necessity of cost engineering limits the applicability of RL in the real world because it requires both RL expertise and domain-speciﬁc knowledge.
Moreover, it is not applicable in situations where we do not know what admissible behaviour may look like.
Therefore, it is of great practical importance to develop algorithms which can learn from unshaped reward signals, e.g. a binary signal indicating successful task completion.
In environments where reward is sparse, only a small fraction of the agents’ experiences are directly used to update the policy, leading to substantial inefﬁciencies during training.
In the domain of goal-directed RL, the recently proposed hindsight experience replay (HER) (Andrychowicz et al., 2017) addresses the challenge of learning from sparse rewards by re-labelling visited states as goal states during training.
However, this technique continues to suffer from sample inefﬁciency, ostensibly due to difﬁculties related to exploration.
In this work, we address these limitations by introducing a method called
Competitive Experience Replay (CER) .
This technique attempts to emphasize exploration by introducing a competition between two agents attempting to learn the same task.
Intuitively, agent A (the agent ultimately used for evaluation) receives a penalty for visiting states that the competitor agent ( B ) also visits; and B is rewarded for visiting states found by A .
Our approach maintains the reward from the original task such that exploration is biased towards the behaviors best suited to accomplishing the task goals.
We show that this competition between agents can automatically generate a curriculum of exploration and shape otherwise sparse reward.
We jointly train both agents’ policies by adopting methods from multi-agent RL.
In addition, we propose two versions of CER, independent CER , and interact CER , which differ in the state initialization of agent B : whether it is sampled from the initial state distribution or sampled from off-policy samples of agent A , respectively.
Whereas HER re-labels samples based on an agent’s individual rollout, our method re-labels samples based on intra-agent behavior; as such, the two methods do not interfere with each other algorithmically and are easily combined during training.
We evaluate our method both with and without HER on a variety of reinforcement learning tasks, including navigating an ant agent to reach a goal position and manipulating objects with a robotic arm.
For each such task the default reward is sparse, corresponding to a binary indicator of goal completion.
Ablation studies show that our method is important for achieving a high success rate and often demonstrates faster convergence.
Interestingly, we ﬁnd that CER and HER are complementary methods and employ both to reach peak efﬁciency and performance.
Furthermore, we observe that, when combined with
HER, CER outperforms curiosity-driven exploration.
B ACKGROUND
Here, we provide an introduction to the relevant concepts for reinforcement learning with sparse reward (Section 2.1), Deep Deterministic Policy Gradient, the backbone algorithm we build off of, (Section 2.2), and
Hindsight Experience Replay (Section 2.3).
S PARSE R EWARD
R EINFORCEMENT L EARNING
Reinforcement learning considers the problem of ﬁnding an optimal policy for an agent that interacts with an uncertain environment and collects reward per action.
The goal of the agent is to maximize its cumulative reward.
Formally, this problem can be viewed as a Markov decision process over the environment states s ∈ S and agent actions a ∈ A , with the (unknown) environment dynamics deﬁned by the transition probability
T ( s (cid:48) | s, a ) and reward function r ( s t , a t ) , which yields a reward immediately following the action a t performed in state s t .
We consider goal-conditioned reinforcement learning from sparse rewards.
This constitutes a modiﬁcation to the reward function such that it depends on a goal g ∈ G , such that r g : S ×
A × G → R .
Every episode starts with sampling a state-goal pair from some distribution p ( s 0 , g ) .
Unlike the state, the goal stays ﬁxed for the whole episode.
At every time step, an action is chosen according to some policy π , which is expressed as a function of the state and the goal, π : S × G → A .
For generality, our only restriction on G is that it is a subset of S .
In other words, the goal describes a target state and the task of the agent is to reach that state.
Therefore, we apply the following sparse reward function:
[Equation]
where g is a goal, | s t − g | is a distance measure, and δ is a predeﬁned threshold that controls when the goal is considered completed.
Following policy gradient methods, we model the policy as a conditional probability distribution over states, π θ ( a | [ s, g ]) , where [ s, g ] denotes concatenation of state s and goal g , and θ are the learnable parameters.
Our objective is to optimize θ with respect to the expected cumulative reward, given by:
[Equation]
where ρ π ( s ) =
(cid:80) ∞ t =1 γ t − 1 Pr( s t = s ) is the normalized discounted state visitation distribution with discount factor γ ∈ [0 , 1) .
To simplify the notation, we denote E s ∼ ρ π ,a ∼ π ( a | s,g ) ,g ∼ G [ · ] by simply E π [ · ] in the rest of paper.
According to the policy gradient theorem (Sutton et al., 1998), the gradient of J ( θ ) can be written as
[Equation]
where Q π ( s, a, g )
=
E π (cid:2)(cid:80) ∞ t =1 γ t − 1 r g ( s t , a t , g ) | s 1 = s, a 1 = a (cid:3) , called the critic, denotes the expected return under policy π after taking an action a in state s , with goal g .
2. DDPG ALGORITHM
Here, we introduce Deep Deterministic Policy Gradient (DDPG) (Lillicrap et al., 2015), a model-free RL algorithm for continuous action spaces that serves as our backbone algorithm.
Our proposed modiﬁcations need not be restricted to DDPG; however, we leave experimentation with other continuous control algorithms to future work.
In DDPG, we maintain a deterministic target policy µ ( s, g ) and a critic Q ( s, a, g ) , both implemented as deep neural networks (note: we modify the standard notation to accommodate goal-conditioned tasks).
To train these networks, episodes are generated by sampling actions from the policy plus some noise, a ∼ µ ( s, g ) + N (0 , 1) .
The transition tuple associated with each action ( s t , a t , g t , r t , s t +1 ) is stored in the so-called replay buffer.
During training, transition tuples are sampled from the buffer to perform mini-batch gradient descent on the loss L which encourages the approximated Q-function to satisfy the Bellman equation
L = E ( Q ( s t , a t , g t ) − y t ) 2 , where y t
=
r t + γQ ( s t +1 , µ ( s t +1 , g t ) , g t ) .
Similarly, the actor can be updated by training with mini-batch gradient descent on the loss J ( θ ) =
− E s Q ( s, µ ( s, g ) , g ) through the deterministic policy gradient algorithm
(Silver et al., 2014),
[Equation]
To make training more stable, the targets y t are typically computed using a separate target network, whose weights are periodically updated to the current weights of the main network (Lillicrap et al., 2015; Mnih et al., 2013; 2015).
2. H INDSIGHT EXPERIENCE REPLAY
Despite numerous advances in the application of deep learning to RL challenges, learning in the presence of sparse rewards remains a major challenge.
Intuitively, these algorithms depend on sufﬁcient variability within the encountered rewards and, in many cases, random exploration is unlikely to uncover this variability if goals are difﬁcult to reach.
Recently, Andrychowicz et al.
(2017) proposed Hindsight Experience Replay (HER) as a technique to address this challenge.
The key insight of HER is that failed rollouts (where no task reward was obtained) can be treated as successful by assuming that a visited state was the actual goal.
Basically, HER amounts to a relabelling strategy.
For every episode the agent experiences, it gets stored in the replay buffer twice: once with the original goal pursued in the episode and once with the goal replaced with a future state achieved in the episode, as if the agent were instructed to reach this state from the beginning.
Formally, HER randomly samples a mini-batch of episodes in buffer, for each episode ( { s i } Ti =1 , { g i } Ti =1 , { a i } Ti =1 , { r i } Ti =1 , { s (cid:48) i } Ti =1 ) , for each state s t , where 1 ≤ t ≤ T − 1 in an episode, we randomly choose s k where t + 1 ≤ k ≤ T and relabel transition ( s t , a t , g t , r t , s t +1 ) to ( s t , a t , s k , r (cid:48) t , s t +1 ) and recalculate reward r (cid:48) t , r (cid:48) t =
[Equation]
g ( s t , s k )
= (cid:26) 0 , if | s t − s k | < δ, − 1 , otherwise.
M ETHOD
In this section, we present Competitive Experience Replay (CER) for policy gradient methods (Section 3.1) and describe the application of multi-agent DDPG to enable this technique (Section 3.2).
3. C OMPETITIVE EXPERIENCE REPLAY
While the re-labelling strategy introduced by HER provides useful rewards for training a goal-conditioned policy, it assumes that learning from arbitrary goals will generalize to the actual task goals.
As such, exploration remains a fundamental challenge for goal-directed RL with sparse reward.
We propose a relabelling strategy designed to overcome this challenge.
Our method is partly inspired by the success of self-play in learning to play competitive games, where sparse rewards (i.e. win or lose) are common.
Rather than train a single agent, we train a pair of agents on the same task and apply an asymmetric reward relabelling strategy to induce a competition designed to encourage exploration.
We call this strategy Competitive
Experience Replay (CER).
To implement CER, we learn a policy for each agent, π A and π B , as well as a multi-agent critic (see below), taking advantage of methods for decentralized execution and centralized training.
During decentralized execution, π A and π B collect DDPG episode rollouts in parallel.
Each agent effectively plays a singleplayer game; however, to take advantage of multi-agent training methods, we arbitrarily pair the rollout from π A with that from π B and store them as a single, multi-agent rollout in the replay buffer D .
When training on a mini-batch of off policy samples, we ﬁrst randomly sample a mini-batch of episodes in D and then randomly sample transitions in each episode.
We denote the resulting mini-batch of transitions as { ( s iA , a iA , g iA , r iA , s (cid:48) iA ) , ( s iB , a iB , g iB , r iB , s (cid:48) iB ) } mi =1 , where m is the size of the mini-batch.
Reward re-labelling in CER attempts to create an implicit exploration curriculum by punishing agent A for visiting states that agent B also visited, and, for those same states, rewarding agent B .
For each A state s iA in a mini-batch of transitions, we check if any B state s jB in the mini-batch satisﬁes | s iA − s jB | < δ and, if so, re-label r iA with r iA − 1 .
Conversely, each time such a nearby state pair is found, we increment the associated reward for agent B , r jB , by +1 .
Each transition for agent A can therefore be penalized only once, whereas no restriction is placed on the extra reward given to a transition for agent B .
Following training both agents with the re-labelled rewards, we retain the policy π A for evaluation.
Additional implementation details are provided in the appendix (Section D).
We focus on two variations of CER that satisfy the multi-agent self-play requirements: ﬁrst, the policy π B receives its initial state from the task’s initial state distribution; second, although more restricted to re-settable environments, π B receives its initial state from a random off-policy sample of π A .
We refer to the above methods as independent-CER and interact-CER , respectively, in the following sections.
Importantly, CER re-labels rewards based on intra-agent behavior, whereas HER re-labels rewards based on each individual agent’s behavior.
As a result, the two methods can be easily combined.
In fact, as our experiments demonstrate, CER and HER are complementary and likely reﬂect distinct challenges that are both addressed through reward re-labelling.
3. G OAL CONDITIONED MULTI - AGENT LEARNING
We extend multi-agent DDPG (MADDPG), proposed by Lowe et al.
(2017), for training using CER.
MADDPG attempts to learn a different policy per agent and a single, centralized critic that has access to the combined states, actions, and goals of all agents.
More precisely, consider a game with N agents with policies parameterized by θθθ = { θ 1 , . .
, θ N } , and let πππ = { π 1 , . . .
, π N } be the set of all agent policies.
g =
[ g 1 , . . .
, g N ] represents the concatenation of each agent’s goal, s =
[ s 1 , . .
, s N ] the concatenated states, and a =
[ a 1 , . .
. , a N ] the concatenated actions.
With this notation, we can write the gradient of the expected return for agent i , J ( θ i ) =
E [ R i ] as:
[Equation] [Equation]
With deterministic policies µµµ = { µ 1 , . . . , µ N } , the gradient becomes:
[Equation]
The centralized action-value function Q µµµi , which estimates the expected return for agent i , is updated as:
[Equation]
where µµµ (cid:48) = { µµµ θ (cid:48) 1 , ...,µµµ θ (cid:48) N } is the set of target policies with delayed parameters θ (cid:48)
i .
In practice people usually soft update it as θ (cid:48)
i ←
τθ i + (1 − τ ) θ (cid:48)
i , where τ is a Polyak coefﬁcient.
During training, we collect paired rollouts as described above, apply any re-labelling strategies (such as CER or HER) and use the MADDPG algorithm to train both agent policies and the centralized critic, concatenating states, actions, and goals where appropriate.
Putting everything together, we summarize the full method in
Algorithm 1.
E XPERIMENT
[Figure]
s u cce ss r a t e    50 0.
s u cce ss r a t e    100 0.
PPODDPGHERHER+ind-CERHER+int-CERind-
[Figure]
4. C OMBINING COMPETITIVE EXPERIENCE REPLAY WITH EXISTING METHODS
We start by asking whether CER improves performance and sample efﬁciency in a sparse reward task.
To this end, we constructed two different mazes, an easier ’U’ shaped maze and a more difﬁcult ’S’ shaped maze (Figure 1).
The goal of the ant agent is to reach the target mark by a red sphere, whose location is randomly sampled for each new episode.
At each step, the agent obtains a reward of 0 if the goal has been achieved and − 1 otherwise.
Additional details of the ant maze environments are found in Appendix B.
An advantage of this environment is that it can be reset to any given state, facilitating comparison between our two proposed variants of CER ( int -CER requires the environment to have this feature).
We compare agents trained with HER, both variants of CER, and both variants of CER with HER.
Since each uses DDPG as a backbone algorithm, we also include results from a policy trained using DDPG alone.
To conﬁrm that any difﬁculties are not simply due to DDPG, we include results from a policy trained using
Proximal Policy Optimization (PPO) (Schulman et al., 2017).
The results for each maze are shown in Figure 1.
DDPG and PPO each performs quite poorly by itself, likely due to the sparsity of the reward in this task set up.
Adding CER to DDPG partially overcomes this limitation in terms of ﬁnal success rate, and, notably, reaches this stronger result with many fewer examples.
A similar result is seen when adding HER to DDPG.
Importantly, adding both HER and CER offers the best improvement of ﬁnal success rate without requiring any observable increase in the number of episodes, as compared to each of the other baselines.
These results support our hypothesis that existing state-of-the-art methods do not sufﬁciently address the exploration challenge intrinsic to sparse reward environments.
Furthermore, these results show that CER improves both the quality and efﬁciency of learning in such challenging settings, especially when combined with HER.
These results also show that int -CER tends to outperform ind -CER.
As such, int -CER is considered preferable but has more restrictive technical requirements.
To examine the efﬁcacy of our method on a broader range of tasks, we evaluate the change in performance when ind -CER is added to HER on the challenging multi-goal sparse reward environments introduced in
Plappert et al.
(Note: we would prefer to examine int -CER but are prevented by technical issues related to the environment.)
Results for each of the 12 tasks we trained on are illustrated in Figure 2.
Our method, when used on top of HER, improves performance wherever it is not already saturated.
This is especially true on harder tasks, where HER alone achieves only modest success (e.g., HandManipulateEggFull and handManipulatePenRotate).
These results further support the conclusion that existing methods often fail to achieve sufﬁcient exploration.
Our method, which provides a targeted solution to this challenge, naturally complements HER.
[Table]
[Figure]
HandReach
HandManipulateBlockFull
[Figure]
HandManipulatePenRotate s u cce ss r a t e
[Figure]
HandManipulateBlockRotateZ
HandManipulateBlockRotateParallel
HandManipulateEggRotate
HandManipulateBlockRotateXYZ s u cce ss r a t e
[Figure]
4. C OMPARING CER WITH CURIOSITY - DRIVEN EXPLORATION
CER is designed to encourage exploration, but, unlike other methods, uses the behavior of a competitor agent to automatically determine the criteria for exploratory reward.
Numerous methods have been proposed for improving exploration; for example, count-based exploration (Bellemare et al., 2016; Tang et al., 2017),
VIME (Houthooft et al., 2016), bootstrap DQN (Osband et al., 2016), goal exploration process (Forestier et al., 2017), parameter space noise (Plappert et al., 2017), dynamics curiosity and boredom (Schmidhuber, 1991), and EX2 (Fu et al., 2017).
One recent and popular method, intrinsic curiosity module (ICM) (Pathak et al., 2017; Burda et al., 2018), augments task reward with curiosity-driven reward.
Much like CER and HER, ICM provides a method to relabel the reward associated with each transition; this reward comes from the error in a jointly trained forward prediction model.
We compare how CER and ICM affect task performance and how they interact with HER across 4 tasks where we were able to implement ICM successfully.
Figureshows the results on several robotic control and maze tasks.
We observe CER to consistently outperform ICM when each is implemented in isolation.
In addition, we observe HER to beneﬁt more from the addition of CER than of ICM.
Compared to ICM, CER also tends to improve the speed of learning.
These results suggest that the underlying problem is not a lack of diversity of states being visited but the size of the state space that the agent must explore (as also discussed in Andrychowicz et al.
One interpretation is that, since the two CER agents are both learning the task, the dynamics of their competition encourage more task-relevant exploration.
From this perspective, CER provides an automatic curriculum for exploration such that visited states are utilized more efﬁciently.
[Figure]
[Table]
[Figure] [Figure]
4. A NALYSIS OF CER
Figure 4 illustrates the success rates of agents A and B as well as the ‘effect ratio,’ which is the fraction of mini-batch samples whose reward is changed by CER during training, calculated as φ = NM where N is the number of samples changed by CER and M is the number of samples in mini-batch.
We observe a strong correspondence between the success rate and effect ratio, likely reﬂecting the inﬂuence of CER on the learning dynamics.
While a deeper analysis would be required to concretely understand the interplay of these two terms, we point out that CER re-labels a substantial fraction of rewards in the mini-batch.
Interestingly, even the relatively small effect ratio observed in the ﬁrst few epochs is enough support rapid learning.
We speculate that the sampling strategy used in int -CER provides a more targeted re-labelling, leading to the more rapid increase in success rate for agent A .
We observe that agent B reaches a lower level of performance.
This likely results from resetting the parameters of agent B periodically during early training, which we observe to improve the ultimate performance of agent A (see Section D for details).
It is also possible that the reward structure of CER asymmetrically beneﬁts agent A with respect to the underlying task.
To gain additional insight into how each method inﬂuences the behaviors learned across training, we visualize the frequency with which each location in the ‘U’ maze is visited after the 5th and 35th training epoch (Figure 5).
Comparing DDPG and HER shows that the latter clearly helps move the state distribution towards the s u cce ss r a t e    50 0.
e ff ec t r a ti o    50 0.
s u cce ss r a t e    50 0.
e ff ec t r a ti o    50 0.
[Figure]
goal, especially during the early parts of training.
When CER is added, states near the goal create a clear mode in the visitation distribution.
This is never apparent with DDPG alone and only obvious for HER and
ICM+HER later in training.
CER also appears to focus the visitation of the agent, as it less frequently gets caught along the outer walls.
These disparities are emphasized in Figure 6, where we show the difference in the visitation proﬁles.
The left two plots compare CER+HER vs. HER.
The right two plots compare Agent
A vs Agent B from CER+HER.
Interestingly, the Agents A and B exhibit fairly similar aggregate visitation proﬁles with the exception that Agent A reaches the goal more often later during training.
These visitation proﬁles underscore both the quantitative and qualitative improvements associated with CER.
[Figure] [Figure]
[Figure] [Figure]
[Figure] [Figure]
R ELATED W ORK
Self-play has a long history in this domain of research (Samuel, 1959; Tesauro, 1995; Heess et al., 2017).
Silver et al.
(2017a) use self-play with deep reinforcement learning techniques to master the game of Go; and self-play has even been applied in Dota 5 v 5 (OpenAI, 2018).
Curriculum learning is widely used for training neural networks (see e.g., Bengio et al., 2009; Graves et al., 2017; Elman, 1993; Olsson, 1995).
A general framework for automatic task selection is Powerplay (Schmidhuber, 2013; Srivastava et al., 2013), which proposes an asymptotically optimal way of selecting tasks from a set of tasks with program search, and use replay buffer to avoid catastrophic forgetting.
Florensa et al.
; Held et al.
(2017) propose to automatically adjust task difﬁculty during training.
Forestier et al.
(2017) study intrinsically motivated goal for robotic learning.
Recently, Sukhbaatar et al.
(2017) suggest to use self-play between two agents where reward depends on the time of the other agent to complete to enable implicit curriculum.
Our work is similar to theirs, but we propose to use sample-based competitive experience replay, which is not only more readily scalable to high-dimension control but also integrates easily with Hindsight Experience Replay (Andrychowicz et al., 2017).
The method of initializing based on a state not sampled from the initial state distribution has been explored in other works.
For example, Ivanovic et al.
(2018) propose to create a backwards curriculum for continuous control tasks through learning a dynamics model.
Resnick et al.
(2018b)
and Salimans & Chen (2018) propose to train policies on Pommerman (Resnick et al., 2018a) and the Atari game ‘Montezumas Revenge’ by starting each episode from a different point along a demonstration.
Recently, Goyal et al.
and Edwards et al.
(2018) propose a learned backtracking model to generate traces that lead to high value states in order to obtain higher sample efﬁciency.
Experience replay has been introduced in (Lin, 1992) and later was a crucial ingredient in learning to master
Atari games (Mnih et al., 2013; 2015). Wang et al. (2016) propose truncation with bias correction to reduce variance from using off-policy data in buffer and achieves good performance on continuous and discrete tasks. Different approaches have been proposed to incorporate model-free learning with experience replay(Gu et al., 2016;
Feng et al., 2019).
Schaul et al.
(2015) improve experience replay by assigning priorities to transitions in the buffer to efﬁciently utilize samples.
Horgan et al.
(2018) further improve experience replay by proposing a distributed RL system in which experiences are shared between parallel workers and accumulated into a central replay memory and prioritized replay is used to update the policy based on the diverse accumulated experiences.
C ONCLUSION
We introduce Competitive Experience Replay, a new and general method for encouraging exploration through implicit curriculum learning in sparse reward settings.
We demonstrate an empirical advantage of our technique when combined with existing methods in several challenging RL tasks.
In future work, we aim to investigate richer ways to re-label rewards based on intra-agent samples to further harness multi-agent competition, it’s interesting to investigate counterfactual inference to promote efﬁcient re-label off-policy samples.
We hope that this will facilitate the application of our method to more open-end environments with even more challenging task structures.
In addition, future work will explore integrating our method into approaches more closely related to model-based learning, where adequate exposure to the dynamics of the environment is often crucial.
A A LGORITHM
We summarize the algorithm for HER with CER in Algorithm 1.
Algorithm 1 HER with CER
Initialize a random process N for action exploration, max episode length to L Set CER to ind-CER or int-CER for episode = 1 to M do
Receive initial state s A Receive a goal r A for this episode
Initialize episode buffer buffer A for t = 1 to L do select action a A = µµµ θ i ( s A )
+ N t w.r.t.
the current policy and exploration Execute actions a
A and observe reward r A and new state s (cid:48)
A Store ( s A , a A , g A , r A , s A (cid:48) ) in buffer
A s A ← s (cid:48)
A end for
Receive initial state s B or Receive initial state s B , where s B is a state sampled from buffer A Receive a goal r B for this episode
Initialize episode buffer buffer B for t = 1 to L do select action a B = µµµ θ i ( s B )
+ N t w.r.t.
the current policy and exploration Execute actions a
B and observe reward r B and new state s (cid:48)
B Store ( s B , a B , g B , r B , s B (cid:48) ) in buffer B s B ← s (cid:48) B end for
Concatenate buffer A and buffer B and store ( { s i } Ti =1 , { a i } Ti =1 , { g i } Ti =1 , { r i } Ti =1 , { s (cid:48) i } Ti =1 ) in replay buffer D // Optimization based on off-policy samples for k = 1 to K do //
Relabelling off-policy samples
Sample a random minibatch of S samples ( s j , a j , g j , r j , s (cid:48) j ) from D
Apply HER strategy on samples Apply ind-CER or int-CER strategy on samples for agent i
=
A, B do
Do one step optimization based on Eq (6) and Eq (7), and update target networks.
end for end for end for
B
E NVIRONMENT
DETAILS
Robotic control environments The robotic control environments shown in Figure 7 are part of challenging continuous robotics control suite (Plappert et al., 2018) integrated in OpenAI Gym (Brockman et al., 2016) and based on Mujoco simulation enginge (Todorov et al., 2012).
The Fetch environments are based on the 7-DoF Fetch robotics arm, which has a two-ﬁngered parallel gripper.
The Hand environments are based on the Shadow Dexterous Hand, which is an anthropomorphic robotic hand with 24 degrees of freedom.
In all tasks, rewards are sparse and binary:
the agent obtains a reward of 0 if the goal has been achieved and −otherwise.
For more details please refer to Plappert et al.
Ant maze environments We also construct two maze environments with the re-settable property, rendered in Figure 1, in which walls are placed to construct ”U” or ”S” shaped maze.
At the beginning of each episode,
[Figure]
HandManipulateBlock
[Figure]
the agent is always initialized at position (0 , 0) , and can move in any direction as long as it is not obstructed by a wall.
The x- and y-axis locations of the target ball are sampled uniformly from [ − 5 , 20] , [ − 5 , 20] , respectively.
C C OMPETITIVE EXPERIENCE REPLAY WITH DIFFERENT ADVERSARIAL AGENTS
[Figure]
cce ss
[Figure]
As Andrychowicz et al.
(2017) and Andrychowicz et al.
(2018) observe (and we also observe), performance depends on the batch size.
We leverage this observation to tune the relative strengths of Agents A and B by separately manipulating the batch sizes used for updating each.
For simplicity, we control the batch size by changing the number of MPI workers devoted to a particular update.
Each MPI worker computes the gradients for a batch size of 256 ; averaging the gradients from each worker results in an effective batch size of N ∗ 256 .
For our single-agent baselines, we choose N =workers, and, when using CER, a default of N = 15 for each A and B
In the following, AxBy denotes, for agent A , N = x and, for agent B , N = y .
These results suggest that, while a sufﬁciently large batch size is important for achieving the best performance, the optimal conﬁguration occurs when the batch sizes used for the two agents are balanced.
Interestingly, we observe that batch size imbalance adversely effects both agents trained during CER.
D I MPLEMENTATION DETAILS
In the code for HER (Andrychowicz et al., 2017), the authors use MPI to increase the batch size.
MPI is used here to run rollouts in parallel and average gradients over all MPI workers.
We found that MPI is crucial for good performance, since training for longer time with a smaller batch size gives sub-optimal performance.
This is consistent with the authors’ ﬁndings in their code that having a much larger batch size helps a lot.
For each experiment, we provide the per-worker batch sizes in Table 1; note that the effective batch size is multiplied by the number of MPI workers N .
In our implementation, we do N rollouts in parallel for each agent and have separate optimizers for each.
We found that periodically resetting the parameters of agent B in early stage of training helps agent A more consistently reach a high level of performance.
This resetting helps to strike an optimal balance between the inﬂuences of HER and CER in training agent A .
We also add L2 regularization, following the practice of
Andrychowicz et al.
For the experiments with neural networks, all parameters are randomly initialized from N (0 , 0 . 2) .
We use networks with three layers of hidden layer size 256 and Adam (Kingma & Ba, 2014) for optimization.
Presented results are averaged over 5 random seeds.
We summarize the hyperparameters in Table
[Table]