Policy Continuation with Hindsight Inverse Dynamics

10/30/2019 ∙ by Hao Sun, et al. ∙ 8

Solving goal-oriented tasks is an important but challenging problem in reinforcement learning (RL). For such tasks, the rewards are often sparse, making it difficult to learn a policy effectively. To tackle this difficulty, we propose a new approach called Policy Continuation with Hindsight Inverse Dynamics (PCHID). This approach learns from Hindsight Inverse Dynamics based on Hindsight Experience Replay. Enabling the learning process in a self-imitated manner and thus can be trained with supervised learning. This work also extends it to multi-step settings with Policy Continuation. The proposed method is general, which can work in isolation or be combined with other on-policy and off-policy algorithms. On two multi-goal tasks GridWorld and FetchReach, PCHID significantly improves the sample efficiency as well as the final performance.



There are no comments yet.


page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Imagine you are given the task of Tower of Hanoi with ten disks, what would you probably do to solve this complex problem? This game looks daunting at the first glance. However through trials and errors, one may discover the key is to recursively relocate the disks on the top of the stack from one pod to another, assisted by an intermediate one. In this case, you are actually learning skills from easier sub-tasks and those skills help you to learn more. This case exemplifies the procedure of self-imitated curriculum learning, which recursively develops the skills of solving more complex problems.

Tower of Hanoi belongs to an important kind of challenging problems in Reinforcement Learning (RL), namely solving the goal-oriented tasks. In such tasks, rewards are usually very sparse. For example, in many goal-oriented tasks, a single binary reward is provided only when the task is completed 1, 2, 3. Previous works attribute the difficulty of the sparse reward problems to the low efficiency in experience collection 4. Thus many approaches have been proposed to tackle this problem, including automatic goal generation 5

, self-imitation learning 

6, hierarchical reinforcement learning 7, curiosity driven methods 8, 9, curriculum learning 1, 10, and Hindsight Experience Replay (HER) 11. Most of these works guide the agent by demonstrating on successful choices based on sufficient exploration to improve learning efficiency. Differently, HER opens up a new way to learn more from failures, assigning hindsight credit to primal experiences. However, it is limited by only applicable when combined with off-policy algorithms3.

In this paper we propose an approach of goal-oriented RL called Policy Continuation with Hindsight Inverse Dynamics (PCHID), which leverages the key idea of self-imitate learning. In contrast to HER, our method can work as an auxiliary module for both on-policy and off-policy algorithms, or as an isolated controller itself. Moreover, by learning to predict actions directly from back-propagation through self-imitation 12, instead of temporal difference 13 or policy gradient 14, 15, 16, 17, the data efficiency is greatly improved.

The contributions of this work lie in three aspects: (1) We introduce the state-goal space partition for multi-goal RL and thereon define Policy Continuation (PC) as a new approach to such tasks. (2) We propose Hindsight Inverse Dynamics (HID), which extends the vanilla Inverse Dynamics method to the goal-oriented setting. (3) We further integrate PC and HID into PCHID, which can effectively leverage self-supervised learning to accelerate the process of reinforcement learning. Note that PCHID is a general method. Both on-policy and off-policy algorithms can benefit therefrom. We test this method on challenging RL problems, where it achieves considerably higher sample efficiency and performance.

2 Related Work

Hindsight Experience Replay

Learning with sparse rewards in RL problems is always a leading challenge for the rewards are usually uneasy to reach with random explorations. Hindsight Experience Replay (HER) which relabels the failed rollouts as successful ones is proposed by Andrychowicz et al. 11 as a method to deal with such problem. The agent in HER receives a reward when reaching either the original goal or the relabeled goal in each episode by storing both original transition pairs and relabeled transitions in the replay buffer. HER was later extended to work with demonstration data 4 and boosted with multi-processing training 3. The work of Rauber et al. 18 further extended the hindsight knowledge into policy gradient methods using importance sampling.

Inverse Dynamics

Given a state transition pair , the inverse dynamics  19 takes as the input and outputs the corresponding action

. Previous works used inverse dynamics to perform feature extraction 

20, 9, 21 for policy network optimization. The actions stored in such transition pairs are always collected with a random policy so that it can barely be used to optimize the policy network directly. In our work, we use hindsight experience to revise the original transition pairs in inverse dynamics, and we call this approach Hindsight Inverse Dynamics. The details will be elucidated in the next section.

Auxiliary Task and Curiosity Driven Method

Mirowski et al. 22 propose to jointly learn the goal-driven reinforcement learning problems with an unsupervised depth prediction task and a self-supervised loop closure classification task, achieving data efficiency and task performance improvement. But their method requires extra supervision like depth input. Shelhamer et al. 21 introduce several self-supervised auxiliary tasks to perform feature extraction and adopt the learned features to reinforcement learning, improving the data efficiency and returns of end-to-end learning. Pathak et al. 20 propose to learn an intrinsic curiosity reward besides the normal extrinsic reward, formulated by prediction error of a visual feature space and improved the learning efficiency. Both of the approaches belong to self-supervision and utilize inverse dynamics during training. Although our method can be used as an auxiliary task and trained in self-supervised way, we improve the vanilla inverse dynamics with hindsight, which enables direct joint training of policy networks with temporal difference and self-supervised learning.

3 Policy Continuation with Hindsight Inverse Dynamics

In this section we first briefly go through the preliminaries in Sec.3.1. In Sec.3.2 we retrospect a toy example introduced in HER as a motivating example. Sec.3.3 to 3.6 describe our method in detail.

3.1 Preliminaries

Markov Decision Process

We consider a Markov Decision Process (MDP) denoted by a tuple

, where , are the finite state and action space, describes the transition probability as . is the reward function and is the discount factor. denotes a policy, and an optimal policy satisfies where , and an is given as a start state. When transition and policy are deterministic, and , , where is deterministic and models the deterministic transition dynamics. The expectation is over all the possible start states.

Universal Value Function Approximators and Multi-Goal RL

The Universal Value Function Approximator (UVFA) 23 extends the state space of Deep Q-Networks (DQN) 24 to include goal state as part of the input, , is extended to . And the policy becomes , which is pretty useful in the setting where there are multiple goals to achieve. Moreover, Schaul  23 show that in such a setting, the learned policy can be generalized to previous unseen state-goal pairs. Our application of UVFA on Proximal Policy Optimization algorithm (PPO) 25 is straightforward. In the following of this work, we will use state-goal pairs to denote the extended state space , and . The goal is fixed within an episode, but changed across different episodes.

3.2 Revisiting the Bit-Flipping Problem

The bit-flipping problem was provided as a motivating example in HER 11, where there are bits with the state space and the action space . An action corresponds to turn the -th bit of the state. Each episode starts with a randomly generated state and a random goal state . Only when the goal state is reached the agent will receive a reward. HER proposed to relabel the failed trajectories to receive more reward signals thus enable the policy to learn from failures. However, the method is based on temporal difference thus the efficiency of data is limited. As we can learn from failures, here comes the question that can we learn a policy by supervised learning where the data is generated using hindsight experience?

Inspired by the self-imitate learning ability of human, we aim to employ self-imitation to learn how to get success in RL even when the original goal has not yet achieved. A straightforward way to utilize self-imitate learning is to adopt the inverse dynamics. However, in most cases the actions stored in inverse dynamics are irrelevant to the goals.

Specifically, transition tuples like

are saved to learn the inverse dynamics of goal-oriented tasks. Then the learning process can be executed simply as classification when action space is discrete or regression when action space is continuous. Given a neural network parameterized by

, the objective of learning inverse dynamics is as follows,

Figure 1: (a): Results in bit-flipping problem. (b): An illustration of flat state space. (c): An example of the GridWorld domain, which is a non-flat case.

Due to the unawareness of the goals while the agent is taking actions, the goals in Eq.(1) are only placeholders. Thus, it will cost nothing to replace with but result in a more meaningful form, , encoding the following state as a hindsight goal. That is to say, if the agent wants to reach from , it should take the action of , thus the decision making process is aware of the hindsight goal. We adopt trained from Eq.(1

) as an additional module incorporating with HER in the Bit-flipping environment, by simply adding up their logit outputs. As shown in Fig.

1(a), such an additional module leads to significant improvement. We attribute this success to the flatness of the state space. Fig.1(b) illustrates such a flatness case where an agent in a grid map is required to reach the goal starting from : if the agent has already known how to reach in the east, intuitively, it has no problem to extrapolate its policy to reach in the farther east.

Nevertheless, success is not always within an effortless single step reach. Reaching the goals of and are relatively harder tasks, and navigating from the start point to goal point in the GridWorld domain shown in Fig.1(c) is even more challenging. To further employ the self-imitate learning and overcome the single step limitation of inverse dynamics, we come up with a new approach called Policy Continuation with Hindsight Inverse Dynamics.

3.3 Perspective of Policy Continuation on Multi-Goal RL Task

Our approach is mainly based on policy continuation over sub-policies, which can be viewed as an emendation of the spontaneous extrapolation in the bit-flipping case.

Definition 1: Policy Continuation(PC)

Suppose is a policy function defined on a non-empty sub-state-space of the state space , i.e., . If is a larger subset of , containing , i.e., and is a policy function defined on such that

then we call a policy continuation of , or we can say the restriction of to is the policy function .

Denote the optimal policy as , we introduce the concept of -step solvability:

Definition 2: -Step Solvability

Given a state-goal pair as a task of a certain system with deterministic dynamics, if reaching the goal needs at least steps under the optimal policy starting from , i.e., starting from and execute for , the state satisfies , we call the pair has -step solvability, or is -step solvable.

Ideally the k-step solvability means the number of steps it should take from to , given the maximum permitted action value. In practice the -step solvability is an evolving concept that can gradually change during the learning process, thus is defined as "whether it can be solve with within steps after the convergence of trained on (-1)-step HIDs".

We follow HER to assume a mapping s.t. the reward function , thus, the information of a goal is encoded in state . For the simplest case we have as identical mapping and where the goal is considered as a certain state of the system.

Following the idea of recursion in curriculum learning, we can divide the finite state-goal space into parts according to their -step solvability,


where , is a finite time-step horizon that we suppose the task should be solved within, and denotes the set of -step solvable state-goal pairs, denotes unsolvable state-goal pairs, , is not -step solvable for , and is the trivial case . As the optimal policy only aims to solve the solvable state-goal pairs, we can take out of consideration. It is clear that we can define a disjoint sub-state-goal space union for the solvable state-goal pairs

Definition 3: Solvable State-Goal Space Partition

Given a certain environment, any solvable state-goal pairs can be categorized into only one sub state-goal space by the following partition


Then, we define a set of sub-policies on solvable sub-state-goal space respectively, with the following definition

Definition 4: Sub Policy on Sub Space

is a sub-policy defined on the sub-state-goal space . We say is an optimal sub-policy if it is able to solve all -step solvable state-goal pair tasks in steps.

Corollary 1:

If is restricted as a policy continuation of for , is able to solve any -step solvable problem for . By definition, the optimal policy is a policy continuation of the sub policy , and is already a substitute for the optimal policy .

We can recursively approximate by expanding the domain of sub-state-goal space in policy continuation from an optimal sub-policy . While in practice, we use neural networks to approximate such sub-policies to do policy continuation. We propose to parameterize a policy function by with neural networks and optimize by self-supervised learning with the data collected by Hindsight Inverse Dynamics (HID) recursively and optimize by joint optimization.

3.4 Hindsight Inverse Dynamics

One-Step Hindsight Inverse Dynamics

One step HID data can be collected easily. With randomly rollout trajectories , we can use a modified inverse dynamics by substituting the original goal with hindsight goal for every and result in . We can then fit by


By collecting enough trajectories, we can optimize

implemented by neural networks with stochastic gradient descent 

26. When is an identical mapping, the function is a good enough approximator for , which is guaranteed by the approximation ability of neural networks 27, 28, 29. Otherwise, we should adapt Eq. 4 as , , we should omit the state information in future state , to regard as a policy. And in practice it becomes .

Multi-Step Hindsight Inverse Dynamics

Once we have , an approximator of , -step HID is ready to get. We can collect valid -step HID data recursively by testing whether the -step HID state-goal pairs indeed need steps to solve, i.e., for any -step transitions , if our policy at hand can not provide with another solution from to in less than steps, the state-goal pair must be -step solvable, and this pair together with the action will be marked as . Fig.2 illustrates this process. The testing process is based on a function and we will focus on the selection of in Sec.3.6. Transition pairs like this will be collected to optimize . In practice, we leverage joint training to ensure to be a policy continuation of i.e.,


3.5 Dynamic Programming Formulation

For most goal-oriented tasks, the learning objective is to find a policy to reach the goal as soon as possible. In such circumstances,


where here is defined as the number of steps to be executed from to with policy and 1 is the additional


and As for the learning process, it is impossible to enumerate all possible intermediate state in the continuous state space and

Suppose now we have the optimal sub-policy of all -step solvable problems , we will have


holds for any . We can sample trajectories by random rollout or any unbiased policies and choose some feasible pairs from them, , any and in a trajectory that can not be solved by the


Such a recursive approach starts from , which can be easily approximated by trained with self supervised learning by any given pairs for by definition.

Figure 2: Test whether the transitions are 2-step (left) or -step (right) solvable. The function returns True if the transition needs at least steps.

The combination of PC and with multi-step HID leads to our algorithm PCHID. PCHID can work alone or as an auxiliary module with other RL algorithms. We discuss three different combination methods of PCHID and other algorithms in Sec.4.3. The full algorithm of the PCHID is presented as Algorithm 1.

Require policy , reward function (equal to 1 if else ), a buffer for PCHID , a list
Initialize , ,
for episode  do
   generate , by the system
   for  do
      Select an action by the behavior policy
      Execute the action and get the next state
      Store the transition in a temporary episode buffer
   end for
   for  do
      for  do
         calculate additional goal according to by
         if  TEST() = True then
            Store in
         end if
      end for
   end for
   Sample a minibatch from buffer
   Optimize behavior policy to predict by supervised learning
   if Converge then
      Add in
   end if
end for
Algorithm 1 Policy Continuation with Hindsight Inverse Dynamics (PCHID)

3.6 On the Selection of TEST Function

In Algorithm 1, a crucial step to extend the -step sub policy to -step sub policy is to test whether a -step transition in a trajectory is indeed a -step solvable problem if we regard as a start state and as a goal . We propose two approaches and evaluate both in Sec.4.


A straightforward idea is to reset the environment to and execute action by policy , followed by execution of , and record if it achieves the goal in less than steps. We call this approach Interaction for it requires the environment to be resettable and interact with the environment. This approach can be portable when the transition dynamics is known or can be approximated without a heavy computation expense.

Random Network Distillation (RND)

Given a state as input, the RND 30 is proposed to provide exploration bonus by comparing the output difference between a fixed randomly initialized neural network and another neural network , which is trained to minimize the output difference between and with previous states. After training with step transition pairs to minimize the output difference between and , since has never seen -step solvable transition pairs, these pairs will be differentiated for they lead to larger output differences.

3.7 Synchronous Improvement

In PCHID, the learning scheme is set to be curriculum, , the agent must learn to master easy skills before learning complex ones. However, in general the efficiency of finding a transition sequence that is -step solvable decreases as increases. The size of buffer is thus decreasing for and the learning of might be restricted due to limited experiences. Besides, in continuous control tasks, the -step solvability means the number of steps it should take from to , given the maximum permitted action value. In practice the -step solvability can be treated as an evolving concept that changes gradually as the learning goes. Specifically, at the beginning, an agent can only walk with small paces as it has learned from experiences collected by random movements. As the training continues, the agent is confident to move with larger paces, which may change the distribution of selected actions. Consequently, previous -step solvable state goal pairs may be solved in less than steps.

Based on the efficiency limitation and the progressive definition of -step solvatbility, we propose a synchronous version of PCHID. Readers please refer to the supplementary material for detailed discussion on the intuitive interpretation and empirical results.

4 Experiments

As a policy aims at reaching a state where , by intuition the difficulty of solving such a goal-oriented task depends on the complexity of . In Sec.4.1 we start with a simple case where is an identical mapping in the environment of GridWorld by showing the agent a fully observable map. Moreover, the GridWorld environment permits us to use prior knowledge to calculate the accuracy of any function. We show that PCHID can work independently or augmented with the DQN in discrete action space setting, outperforming the DQN as well as the DQN augmented with HER. The GridWorld environment corresponds to the identical mapping case . In Sec.4.2 we test our method on a continuous control problem, the FetchReach environment provided by Plappert et al. 3. Our method outperforms PPO by achieving successful rate in about episodes. We further compare the sensitivity of PPO to reward values and the robustness PCHID owns. The state-goal mapping of FetchReach environment is .

4.1 GridWorld Navigation

We use the GridWorld navigation task in Value Iteration Networks (VIN) 31, in which the state information includes the position of the agent, and an image of the map of obstacles and goal position. In our experiments we use domains, navigation in which is not an effortless task. Fig.1(c) shows an example of our domains. The action space is discrete and contains actions leading the agent to its neighbour positions respectively. A reward of will be provided if the agent reaches the goal within timesteps, otherwise the agent will receive a reward of . An action leading the agent to an obstacle will not be executed, thus the agent will stay where it is. In each episode, a new map will randomly selected start and goal points will be generated. We train our agent for episodes in total so that the agent needs to learn to navigate within just trials, which is much less than the number used in VIN 31.222Tarmar et al. train VIN through the imitation learning (IL) with ground-truth shortest paths between start and goal positions. Although both of our approaches are based on IL, we do not need ground-truth data Thus we can demonstrate the high data efficiency of PCHID by testing the learned agent on

unseen maps. Our work follows VIN to use the rollout success rate as the evaluation metric.

Our empirical results are shown in Fig.3. Our method is compared with DQN, both of which are equipped with VIN as policy networks. We also apply HER to DQN but result in a little improvement. PC with -step HID, denoted by PCHID 1, achieves similar accuracy as DQN in much less episodes, and combining PC with -step HID, denoted by PCHID 5, and HER results in much more distinctive improvement.

Figure 3: (a): The rollout success rate on test maps in experiments with different random seeds. HER outperforms VIN, but the difference disappears when combined with PCHID. PCHID-1 and PCHID-5 represent 1-step and 5-step PCHID. (b): Performance of PCHID module alone with different functions. The blue line is from ground truth testing results, the orange line and green line are Interaction and RND respectively, and the red line is the 1-step result as a baseline. (c)(d): Test accuracy and recall with Interaction and RND method under different threshold.

4.2 OpenAI Fetch Env

In the Fetch environments, there are several tasks based on a 7-DoF Fetch robotics arm with a two-fingered parallel gripper. There are four tasks: FetchReach, FetchPush, FetchSlide and FetchPickAndPlace. In those tasks, the states include the Cartesian positions, linear velocity of the gripper, and position information as well as velocity information of an object if presented. The goal is presented as a 3-dimentional vector describing the target location of the object to be moved to. The agent will get a reward of

if the object is at the target location within a tolerance or otherwise. Action is a continuous 4-dimentional vector with the first three of them controlling movement of the gripper and the last one controlling opening and closing of the gripper.


Here we demonstrate PCHID in the FetchReach task. We compare PCHID with PPO and HER based on PPO. Our work is the first to extend hindsight knowledge into on-policy algorithms 3. Fig.4 shows our results. PCHID greatly improves the learning efficiency of PPO. Although HER is not designed for on-policy algorithms, our combination of PCHID and PPO-based HER results in the best performance.

Figure 4: (a): The FetchReach environment. (b): The reward obtaining process of each method. In PPO r10 the reward of achieving the goal becomes instead of as default, and the reward is re-scaled to be comparable with other approaches. This is to show the sensitivity of PPO to reward value. By contrast, the performance of PCHID is unrelated to reward value. (c): The success rate of each method. Combining PPO with PCHID brings about little improvement over PCHID, but combining HER with PCHID improves the performance significantly.

4.3 Combing PCHID with Other RL Algorithms

As PCHID only requires sufficient exploration in the environment to approximate optimal sub-policies progressively, it can be easily plugged into other RL algorithms, including both on-policy algorithms and off-policy algorithms. At this point, the PCHID module can be regarded as an extension of HER for off-policy algorithms. We put forward three combination strategies and evaluate each of them on both GridWorld and FetchReach environment.

Joint Training

The first strategy for combining PCHID with normal RL algorithm is to adopt a shared policy between them. A shared network is trained through both temporal difference learning in RL and self-supervised learning in PCHID. The PCHID module in joint training can be viewed as a regularizer.

Averaging Outputs

Another strategy for combination is to train two policy networks separately, with data collected in the same set of trajectories. When the action space is discrete, we can simply average the two output vectors of policy networks, e.g. the Q-value vector and the log-probability vector of PCHID. When the action space is continuous, we can then average the two predicted action vectors and perform an interpolated action. From this perspective, the RL agent here actually learns how to work based on PCHID and it parallels the key insight of ResNet 

32. If PCHID itself can solve the task perfectly, the RL agent only needs to follow the advice of PCHID. Otherwise, when it comes to complex tasks, PCHID will provide basic proposals of each decision to be made. The RL agent receives hints from those proposals thus the learning becomes easier.

Intrinsic Reward (IR)

This approach is quite similar to the curiosity driven methods. Instead of using the inverse dynamics to define the curiosity, we use the prediction difference between PCHID module and RL agent as an intrinsic reward to motivate RL agent to act as PCHID. Maximizing the intrinsic reward helps the RL agent to avoid aimless explorations hence can speed up the learning process.

Fig.5 shows our results in GridWorld and FetchReach with different combination strategies. Joint training performs the best and it does not need hyper-parameter tuning. On the contrary, the averaging outputs requires determining the weights while the intrinsic reward requires adjusting its scale with regard to the external reward.

Figure 5: (a): Accuracy of GridWorld under different combination strategies. (b): Averaging outputs with different weights. (c): Obtained Reward of FetchReach under different strategies.

5 Conclusion

In this work we propose the Policy Continuation with Hindsight Inverse Dynamics (PCHID) to solve the goal-oriented reward sparse tasks from a new perspective. Our experiments show the PCHID is able to improve data efficiency remarkably in both discrete and continuous control tasks. Moreover, our method can be incorporated with both on-policy and off-policy RL algorithms flexibly.

Acknowledgement: We acknowledge discussions with Yuhang Song and Chuheng Zhang. This work was partially supported by SenseTime Group (CUHK Agreement No.7051699) and CUHK direct fund (No.4055098).


Supplementary Materials

The Ornstein-Uhlenbeck Process Perspective of Synchronous Improvement

For simplicity we consider 1-dimensional state-action space. An policy equipped with Gaussian noise in the action space lead to a stochastic process in the state space. In the most simple case, the mapping between action space and the corresponding change in state space is an affine transformation, i.e., . Without loss of generality, we have


after normalization. The describes the correlations between actions and goal states. e.g., for random initialized policies, the actions are unaware of goal thus , and for optimal policies, the actions are goal-oriented thus . The learning process can be interpreted as maximizing , where better policies have larger . Under those notations,


where is the Wiener Process, and the corresponding discrete time version is . As Eq. (11) is exactly an Ornstein-Uhlenbeck (OU) Process, it has closed-form solutions:


and the expectation is


Intuitively, Eq. (13) shows that as increase during learning, it will take less time to reach the goal. More precisely, we are caring about the concept of First Hitting Time (FHT) of OU process, i.e., 33.

Without loss of generality, we can normalize the Eq.(11) by the transformation:


and we consider the FHT problem of


The probability density function of

, denoted by is


and the expectation is provided as  34, 35, 36


Accordingly, the optimization of solving goal-oriented reward sparse tasks can be viewed as minimizing the FHT of OU process. From this perspective, any action that can reduce the FHT will lead to a better policy.

Inspired by such a perspective, and to tackle the efficiency bottleneck and further improve the performance of PCHID, we extend our method to a synchronous setting based on the evolving concept of -step solvability. We refer to this updated approach as Policy Evolution with Hindsight Inverse Dynamics (PEHID). PEHID start the learning of before the convergence of by merging buffers into one single buffer . And when increasing the buffer with new experiences, we will test an experience that is -step solvable could be reproduced within steps if we change the goal. We retain those experiences that are not reachable as containing new valuable skills for current policy to learn.

  • a policy

  • a reward function if else

  • a buffer for PEHID

  • a list

Initialize ,
for episode  do
   generate , by the system
   for  do
      Select an action by the behavior policy
      Execute the action and get the next state
      Store the transition in a temporary episode buffer
   end for
   for  do
      for  do
         calculate additional goal according to by
         if  TEST() = True then
            Store in
         end if
      end for
   end for
   Sample a minibatch from buffer
   Optimize behavior policy to predict by supervised learning
end for
Algorithm 2 PEHID Module

Empirical Results

We evaluate PEHID in the FetchPush, FetchSlide and FetchPickAndPlace tasks. To demonstrate the high learning efficiency of PEHID, we compare the success rate of different method after 1.25M timesteps, which is amount to 13 epochs in the work of Plappert et. al 

3. Table 1 shows our results.

Method FetchPush FetchSlide FetchPickAndPlace
Table 1: The successful rate of different methods in the FetchPush, FetchSlide and FetchPickAndPlace environments (trained for 1.25M timesteps)