Learning Multi-Objective Curricula for Robotic Policy Learning
Abstract: Various automatic curriculum learning (ACL) methods have been proposed to improve the sample efficiency and final performance of robots’ policies learning.
They are designed to control how a robotic agent collects data, which is inspired by how humans gradually adapt their learning processes to their capabilities.
In this paper, we propose a unified automatic curriculum learning framework to create multi-objective but coherent curricula that are generated by a set of parametric curriculum modules.
Each curriculum module is instantiated as a neural network and is responsible for generating a particular curriculum.
In order to coordinate those potentially conflicting modules in a unified parameter space, we propose a multi-task hyper-net learning framework that uses a single hyper-net to parameterize all those curriculum modules.
We evaluate our method on a series of robotic manipulation tasks and demonstrate its superiority over other state-of-theart ACL methods in terms of sample efficiency and final performance.
Our code is available at https://github.com/luciferkonn/MOC_CoRL22 .
Introduction
The concept that humans frequently organize their learning into a curriculum of interdependent processes according to their capabilities was first introduced to machine learning in [1].
Over time, curriculum learning has become more widely used in machine learning to control the stream of examples provided to training algorithms [2], to adapt model capacity [3] and to organize exploration [4].
Automatic curriculum learning (ACL) for deep reinforcement learning (DRL) [5] has recently emerged as a promising tool to learn how to adapt a robot’s learning tasks to its capabilities during training.
ACL can be applied to robotics’ policies learning in various ways, including adapting initial states [6], shaping reward functions [7], generating goals [8].
More broadly, curriculum learning can also be used to modify the environment itself.
For example, it can add new entities to the world or change the behaviors of other agents [9].
Oftentimes, only a single ACL paradigm ( e.g. , generating subgoals) is considered.
It remains an open question whether different paradigms are complementary to each other and if yes, how to combine them in a more effective manner similar to how the “rainbow” approach of [10] has greatly improved DRL performance in Atari games.
Multi-task learning is notoriously difficult, and Yu et al.
[11] hypothesize that the optimization difficulties might be due to the gradients from different tasks conflicting with each other thus hurting the learning process.
In this work, we propose a multi-task bilevel learning framework for more effective multi-objective curricula robotics’ policy learning.
Concretely, inspired by neural modular systems [12] and multi-task RL [13], we utilize a set of neural modules and train each of them to output a sequence of tasks with different desired goals, rewards, initial states, etc.
To coordinate potentially conflicting gradients from modules in a unified parameter space, we use a single hyper-net [14] to parameterize neural modules so that these modules generate a diverse and cooperative set of curricula.
Multi-task learning provides a natural curriculum for the hyper-net itself since learning easier curriculum modules can be beneficial for learning more difficult curriculum modules with parameters generated by the hyper-net.
Furthermore, existing ACL methods usually rely on manually-designed paradigms of which the target and mechanism have to be clearly defined and it is therefore challenging to create a very diverse set of curriculum paradigms.
Consider goal-based ACL for example, where the algorithm is tasked with learning how to rank goals to form the curriculum [15].
Many of these curriculum paradigms are based on simple intuitions that are inspired by learning in humans, but they usually take too simple forms ( e.g. , generating subgoals) to apply to neural models.
Instead, we propose to augment the hand-designed curricula introduced above with an abstract curriculum of which paradigm is learned from scratch.
More concretely, we take the idea from memory-augmented meta-DRL [16] and equip the hyper-net with a non-parametric memory module, which is also directly connected to the DRL agent.
The hyper-net can write entries to and update items in the memory, through which the DRL agent can interact with the environment under the guidance of the abstract curriculum maintained in the memory.
The write-only permission given to the hyper-net over the memory is distinct from the common use of memory modules in meta-DRL literature, where the memories are both readable and writable.
We point out that the hyper-net is instantiated as a recurrent neural network [17] which has its internal memory mechanism and thus a write-only extra memory module is enough.
Another key perspective is that such a write-only memory module suffices to capture the essence of many curriculum paradigms .
For instance, the subgoal-based curriculum can take the form of a sequence of coordinates in a game which can be easily generated as a hyper-net and stored in the memory module.
The contributions of this work are as follows:
We introduce multi-objective curricula learning approach for improving the sample efficiency of solving challenging deep reinforcement learning tasks, which is an important problem that has not been adequately addressed before.
We further propose a unified automatic curriculum learning framework to create multiobjective but coherent curricula that are generated by a set of parametric curriculum modules.
Each curriculum module is instantiated as a neural network and is responsible for generating a particular curriculum.
To coordinate those potentially conflicting modules in unified parameter space, we propose a multi-task hyper-net learning framework that uses a single hyper-net to parameterize all those curriculum modules
Related Work
Curriculum learning.
Automatic curriculum learning (ACL) for deep reinforcement learning (DRL) [18, 5, 19, 20, 21] has recently emerged as a promising tool to learn how to adapt an agent’s learning tasks based on its capacity during training.
ACL [22] can be applied to DRL in a variety of ways, including adapting initial states [6, 23], shaping reward functions [24, 25], or generating goals [8, 15, 26, 27].
In a closely related work [28], a series of related environments of increasing difficulty have been created to form curricula.
There are other works related to curriculum reinforcement learning (CRL).
Multi-task and neural modules.
Learning with multiple objectives is shown to be beneficial in
DRL tasks [29, 30, 31, 32].
Sharing parameters across tasks [33, 34, 35] usually results in conflicting gradients from different tasks.
One way to mitigate this is to explicitly model the similarity between gradients obtained from different tasks [11, 36, 37, 38, 39, 40, 41].
On the other hand, researchers propose to utilize different modules for different tasks, thus reducing the interference of gradients from different tasks [42, 43, 44, 45, 46, 47, 48].
Most of these methods rely on pre-defined modules that make them not flexible in practice.
One exception is [12], which utilizes soft combinations of neural modules for multi-task robotics manipulation.
However, there is still redundancy in the modules in [12], and those modules cannot be modified during inference.
Instead, we use a hyper-net to dynamically update complementary modules on the fly conditional on the environments.
Memory-augmented meta DRL.
Our approach is also related to episodic memory-based meta DRL [49, 16, 50, 51].
Different from memory-augmented meta DRL methods, the DRL agent in our case is not allowed to modify the memory.
This design prevents the agent from writing its information into the memory module, which can interfere with the generated curriculum.
Note that it is straightforward to augment the DRL agent with both readable and writable neural memory just like [16, 49], which is different from our read-only memory module designed for ACL.
Dynamic neural networks.
Dynamic neural networks [52] can change their structures or parameters based on different environments.
Dynamic filter networks [53] and hyper-nets [14] can both generate parameters.
Our proposed framework generalizes previous work by unifying the aforementioned key concepts with a focus on automatically learning multi-objective curricula from scratch for DRL-based robot learning.
Preliminaries
Reinforcement learning (RL) is used to train an agent policy with the goal of maximizing the (discounted) cumulative rewards through trial and error.
A basic RL setting is modelled as a Markov decision process (MDP) with the following elements: S is the set of environment states.
In this paper, goal g ∈ G corresponds to a set of states S g ⊂ S .
The goal is considered to be achieved when the agent is in any state s t ∈ S g ; A is the set of actions; δ is the state transition probability function, where δ ( s t +1 | s t , a t ) maps a state–action pair at time-step t to a probability distribution over states at time t + 1 ; R is the immediate reward after a transition from s to s ′ ; π ( · ; ϕ π ) is the policy function parameterized by ϕ π , and π ( a | s ; ϕ π ) denotes the probability of choosing action
a given an observation s .
Automatic curriculum learning (ACL) is a learning paradigm where an agent is trained iteratively following a curriculum to ease learning and exploration in a multi-task problem.
Since it is not feasible to manually design a curriculum for each task, recent work has proposed to create an implicit curriculum directly from the task objective.
Concretely, it aims to maximize a metric P computed over a set of target tasks T ∼ T target after some episodes t ′ .
Following the notation in [5], the objective is set to: max D (cid:82) T ∼T target P t ′ T dT , where D : H → T target is a task selection function.
The input H can be consist of any information about past interactions.
For example, in our experiments, the history consists of the last state of the episode. , and the output of D is a sequence of generated episodes, which contain different desired goals, initial states, rewards, etc.
Hyper-networks were proposed in [14] where one network (hyper-net) is used to generate the weights of another network.
All the parameters of both networks are trained end-to-end using backpropagation.
We follow the notation in [54] and suppose that we aim to model a target function y :
X × I → R , where x ∈ X is independent of the task and I ∈ I depends on the task.
A base neural network f b ( x ; f h ( I ; θ h )) can be seen as a composite function, where f b : X → R and f h : I → Θ b .
Conditioned on the task information I , the small hyper -net f h ( I ; θ h ) generates the parameters θ b of base-net f b .
Note that θ b is never updated using loss gradients directly.
Learning Multi-Objective Curricula
We use a single hyper-net to dynamically parameterize all the curriculum modules over time and modify the memory module shared with the DRL agent.
We call this framework a Multi-Objective
Curricula (MOC).
This novel design encourages different curriculum modules to merge and exchange information through the shared hyper-net.
Following the design of hyper-networks with recurrence [14], this hyper-net is instantiated as a recurrent neural network (RNN), which we refer to as the Hyper-RNN , denoted as f h ( I ; θ h ) , in the rest of this paper to emphasize its dynamic nature.
Additionally, the Hyper-RNN can be viewed as a configurator for other modules as suggested in [55].
Our motivation for the adoption of an RNN design is its capability for producing a distinct set of curricula for every episode, which strikes a better trade-off between the number of model parameters and its expressiveness.
On the other hand, each manually designed curriculum module is also instantiated as an RNN, which is referred as a
Base-RNN f b ( x ; θ b ) parameterized by θ b = f h ( I ; θ h ) .
Each Base-RNN is responsible for producing a specific curriculum, e
[Figure]
g. , a series of sub-goals
[Figure]
[Figure]
[Table]
The architecture of MOC-DRL is depicted in Fig. 1, and its corresponding pseudo-code is given in Alg.
We formulate the training procedure as a bilevel optimization problem [56] where we minimize an outer-level objective that depends on the solution of the inner-level tasks.
In our case, the outer -level optimization comes from the curriculum generation loop where each step is an episode denoted as t ′ .
On the other hand, the inner -level optimization involves a common DRL agent training loop on the interactions between the environment and the DRL agent, where each time-step at this level is denoted as t .
We defer the discussion on the details to Sec. 4.3.
Inputs , I , of the Hyper-RNN, f h , consist of: (1) the final state of the last episode, and (2) role identifier for each curriculum module ( e.g. , for initial states generation) represented as a one-hot encoding.
Ideally, we expect each Base-RNN to have its own particular role, which is specific to each curriculum.
When generating the parameters for each Base-RNN, we additionally feed the role identifier representation to the Hyper-RNN.
Outputs of the Hyper-RNN at episode t ′ include: (1) parameters θ t ′ b for each Base-RNN, and (2) the abstract curriculum, h t ′ h , maintained in the memory module.
Here h t ′ h corresponds to the hidden states of the Hyper-RNN such that [ θ t ′ b , h t ′ h ]
= f h ( I t ′ ; θ h ) .
4.1 Manually Designed Curricula
In Sec. 4.1, we describe the details of generating manually designed curricula while the process of updating the abstract curriculum is described in Sec. 4.2.
We describe how to train them in Sec. 4.3.
In this work, we use three curriculum modules responsible for generating pre-defined curricula [5]: initial state generator, sub-goal state generator, and reward shaping generator .
Our approach can be easily extended to include other forms of curricula ( e.g. , selecting environments from a discrete set [57]) by adding another curriculum generator to the shared hyper-net.
These Base-RNNs simultaneously output the actual curricula for the DRL agent in a synergistic manner.
It should be noted that these Base-RNNs are not directly updated by loss gradients, as their pseudo-parameters are generated by the Hyper-RNN.
Generating subgoal state g t as curriculum c goal with Base-RNN ˙ f b .
As one popular choice in
ACL for DRL, the subgoals can be selected from discrete sets [8] or a continuous goal space [15].
A suitable subgoal state g t can ease the learning procedures by guiding the agent on how to achieve subgoals step by step and ultimately solving the final task.
To incorporate the subgoal state in the overall computation graph, in this paper, we adopt the idea from universal value functions [58] and modify the action-value function, Q ( · ; ϕ q ) , to combine the generated subgoal state with other information Q := Q ( s t , a t , g t ; ϕ q ) =
Q ( s t , a t , c goal ; ϕ q ) , where s t is the state, a t is the action, and g t is the generated subgoal state.
The loss is defined as
[Equation]
] , where ˙ y is the one-step look-ahead:
[Equation]
H buf is the replay buffer and λ is the discount factor.
Generating initial state s 0 as curriculum c init with Base-RNN ¨ f b .
Intuitively, if the starting state s 0 for the agent is close to the end-goal state, the training would become easier, which forms a natural curriculum for training tasks whose difficulty depends on a proper distance between the initial state and the end-goal state.
This method has been shown effective in control tasks with sparse rewards [6, 59].
To simplify implementation, even though we only need a single initial state s 0 which is independent of time, we still use a Base-RNN, ¨ f b , to output it.
The loss for this module is: J init =
E ( s t ,a t ) ∼ H buf [( Q ( s t , a t , c init ; ϕ q ) − ˙ y ) 2 ] , where ˙
y is defined in
Eqn. 1.
Generating potential-based shaping function as curriculum c rew with Base-RNN ... f b .
Motivated by the success of using reward shaping for scaling RL methods to handle complex domains [60], we introduce reward shaping as the third manually selected curriculum.
The reward shaping function can take the form of: ...
f ′ b ( s t , a t , s t +1 )
= µ · ...
f b ( s t +1 ) − ...
f b ( s t ) , where µ is a hyper-parameter and ...
f b () is base-RNN that maps the current state with a reward.
In this paper, we add the shaping reward ...
f ′ b ( s t , a t , s t +1 ) to the original environment reward r .
We further normalize the shaping reward between 0 and 1 to deal with wide ranges.
Following the optimal policy invariant theorem [60], we modify the look-ahead function: ...
y =
r t + ...
f b ( s t , a t , s t +1 + λ E a t +1 ∼ π θ ( s t +1 )
[ Q ( s t , a t , c rew ; ϕ q ) − log( π ( a t +1 | s t +1 ; ϕ π ))] .
Thus the loss is defined as: J reward =
E s t ,a t ,s t +1 , a t +1 ∼ H buf [( Q ( s t , a t , c rew ; ϕ q ) − ... y ) 2 ] .
4.2 Abstract Curriculum with Memory Mechanism
Although the aforementioned hand-designed curricula are generic enough to be applied in any environment/task, it is still limited by the number of such predefined curricula.
It is reasonable to conjecture that there exist other curriculum paradigms, which might be difficult to hand-design based on human intuition.
As a result, instead of solely asking the hyper-net to generate human-engineered curricula, we equip the hyper-nets with an external memory, in which the hyper-nets could read and update the memory’s entries.
The Hyper-RNN together with the memory can also be seen as an instantiation of shared workspaces [61] for different curricula modules, in which those modules exchange information.
By design, the content in the memory can serve as abstract curricula for the DRL agent, which is generated and adapted according to the task distribution and the agent’s dynamic capacity during training.
Even though there is no constraint on how exactly the hyper-net learns to use the memory, we observe that (see Sec.
The hyper-net can receive reliable training signals from the manually designed curriculum learning objectives 2 ; 2) Using the memory module alone would result in unstable training; 3) Utilizing both the memory and manual curricula achieves the best performance and stable training.
Thus, training this memory module with other manually designed curriculum modules contributes to the shaping of the content that can be stored in the memory and is beneficial for overall performance.
Specifically, external memory is updated by the Hyper-RNN.
To capture the latent curriculum information, we design a neural memory mechanism similar to [62].
The form of memory is defined as a matrix M .
At each episode t ′ , the Hyper-RNN emits two vectors m t ′ e , and m t ′ a as [ m t ′ e , m t ′ a ] T =
[ σ, tanh ] T ( W t ′ h h t ′ h ) : where W t ′ h is the weight matrix of Hyper-RNN to transform its internal state h t ′ h and t [ · ] denotes matrix transpose.
Note that W h are part of the Hyper-LSTM parameters θ h .
The Hyper-RNN writes the abstract curriculum into the memory, and the DRL agent can read the abstract curriculum information freely.
Reading.
The DRL agent can read the abstract curriculum c abs from the memory M .
The read operation is defined as: c t ′ abs =
α t ′ M t ′ − 1 , where α t ′ ∈ R K represents an attention distribution over the set of entries of memory M t ′ − 1 .
Each scalar element α t ′ ,k in an attention distribution α t ′ can be calculated as: α t ′ ,k = softmax ( cosine ( M t ′ − 1 ,k , m t ′ − 1 a )) , where we choose cosine ( · , · ) as the align function, M t ′ − 1 ,k represents the k -th row memory vector, and m t ′ a ∈ R M is a add vector emitted by Hyper-RNN.
Updating.
The Hyper-RNN can write and update abstract curriculum in the memory module.
The write operation is performed as: M t ′ =
M t ′ − 1 (1 − α t ′ m t ′ e )+ α t ′ m t ′ a , where m t ′ e ∈ R M corresponds to the extent to which the current contents in the memory should be deleted.
Equipped with the above memory mechanism, the DRL learning algorithm can read the memory and utilize the retrieved information for policy learning.
We incorporate the abstract curriculum into the value function by Q ( s t , a t , g t , c t ′ abs ; ϕ q ) .
Similar to manually designed curricula, we minimize the Bellman error and define the loss function for the abstract curriculum as:
J abstract =
E ( s t ,a t ,r t ,s t +1 ,c t ′ abs )
∼ H buf [( Q ( s t , a t , c t ′ abs ; ϕ q ) − ˙ y ) 2 ] ,
where ˙
y is defined in Eqn. 1.
4.3 Bilevel Training of Hyper-RNN
After introducing the manually designed curricula in Sec.
4.1 and the abstract curriculum in Sec.
4.2, here we describe how we update the Hyper-RNN’s parameters θ h , the parameters associated with the DRL agent ϕ q and ϕ π .
Since the Hyper-RNN’s objective is to serve the DRL agent, we naturally formulate this task as a bilevel problem [56] of optimizing the parameters associated with multiobjective curricula generation by nesting one inner-level loop in an outer-level training loop.
Outer-level training of Hyper-RNN.
Specifically, the inner-level loop for the DRL agent learning and the outer-level loop for training Hyper-RNN with hyper-gradients.
The outer-level loss is defined as : J outer =
J initial + J goal + J reward + J abs .
Since the manually designed curricula and abstract curricula are all defined in terms of Q -function, for the implementation simplicity, we combine them together J outer =
E s t ,a t ,s t +1 , a t +1 ∼ H buf [( Q ( s t , a t , c goal , c rew , c init , c abs ; ϕ q ) − ... y ) 2 ] .
Following the formulation and implementation in [56], we obtain θ ∗ h = argmin ( θ h ; J outer (argmin ( ϕ ; J inner ( θ h , ϕ )))) .
Inner-level training of DRL agent.
The parameters associated with the inner-level training, ϕ q and ϕ π , can be updated based on any RL algorithm.
In this paper, we use Proximal Policy Optimization (PPO) [63] which is a popular policy gradient algorithm that learns a stochastic policy.
Experiments
We evaluate and analyze our proposed MOC DRL on the CausalWorld [64], as this environment enables us to easily design and test different types of curricula in a fine-grained manner.
This environment also provides wrapper makes the environment to execute actions on the real robot, which can be used in sim2real experiments.
It should be noted that we do not utilize any causal elements of the environment.
It is straightforward to apply our method to other DRL environments without major modification.
Moreover, the training and evaluation task distributions are handled by CausalWorld.
Take task ”Pushing” as an example: for each outer loop, we use CausalWorld to generate a task with randomly sampled new goal shapes from a goal shape family [Figure]
5.1 Comparing MOC with state-of-the-art ACL methods
We compare our proposed approach with the other state-of-the-art ACL methods: (1) GoalGAN [26], which uses a generative adversarial neural network (GAN) to propose tasks for the agent to finish; (2)
ALP-GMM [5], which models the agent absolute learning progress with Gaussian mixture models.
None of these baselines utilize multiple curricula.
Fig.
2 shows that MOC outperforms other ACL approaches in terms of mean episode reward, fractional success, and sample efficiency.
Especially, MOC increases fractional success by up to 56.2% in all of three tasks, which illustrates the effectiveness of combining multiple curricula in a synergistic manner.
5.2 Ablation Study
Our proposed MOC framework consists of three key parts: the Hyper-RNN trained with hypergradients, multi-objective curriculum modules, and the abstract memory module.
To get a better insight into MOC, we conduct an in-depth ablation study on probing these components.
We first describe the MOC variants used in this section for comparison as follows: (1) MOC Base − : MOC has the Hyper-RNN and the memory module but does not have the Base-RNNs for manually designed curricula.
(2) MOC Memory − : MOC has the Hyper-RNN to generate three curriculum modules but does not have the memory module.
(3) MOC Memory − ,Hyper − : MOC has Base-RNNs but does not have memory and Hyper-RNN components.
It independently generates manually designed curricula.
(4) MOC Memory − ,Goal + : MOC with Hyper-RNN and one Base-RNN, but without the memory module.
It only generates the subgoal curriculum as our pilot experiments show that it is consistently better than the other two manually designed curricula and is easier to analyze its behavior by visualizing the state visitation.
Ablations of Hyper-RNN.
By comparing MOC Memory − with MOC Memory − ,Hyper − as shown in
Fig.
3, we can observe that letting a Hyper-RNN generate the parameters of different curriculum modules indeed helps in improving the sample efficiency and final performance.
The advantage is even more obvious in the harder tasks pick and place and stacking .
The poor performance of [Figure]
i
[Figure]
Reaching
[Figure] Picking [Figure] a
[Figure]
r p i s o d e r e
[Figure]
a r d [Figure] MOC Memory − ,Hyper − may be caused by the potential conflicts among the designed curricula. For example, without coordination between the initial state curriculum and the goal curriculum, the initial state generator may set an initial state close to the goal state, which is easy to achieve by an agent but too trivial to provide useful training information to achieve the final goal.
In sharp contrast, the
Hyper-RNN can solve the potential conflicts from different curricula.
All the curriculum modules are dynamically generated by the same hyper-net, and there exists an implicit information sharing between the initial state and the goal state curriculum generator.
We put extra experimental results in
Appendix Sec.
A.3, Fig. 5.
Ablations of the memory module.
We aim to provide an empirical justification for the use of the memory module and its associated abstract curriculum.
By comparing MOC with MOC Memory − as shown in Fig.
3, we can see that the memory module is crucial for MOC to improve sample efficiency and final performance.
Noticeably, in pick and place and stacking , we see that
MOC gains a significant improvement due to the incorporation of the abstract curriculum.
We expect that the abstract curriculum could provide the agent with an extra implicit curriculum that is complementary to the manually designed curricula.
We also find that it is better for the Hyper-RNN to learn the abstract curriculum while generating other manually designed curricula.
Learning multiple manually designed curricula provides a natural curriculum for the Hyper-RNN itself since learning easier curriculum modules can be beneficial for learning of more difficult curriculum modules with parameters generated by the Hyper-RNN.
Ablations of individual curricula.
We now investigate how gradually adding more curricula affects the training of DRL agents.
By comparing MOC Memory − ,Goal + and MOC Memory − as shown in
Fig.
3, we observe that training an agent with a single curriculum receives less environmental rewards as compared to the ones based on multiple curricula.
This suggests that the set of generated curricula indeed helps the agent to reach intermediate states that are aligned with each other and also guides the agent to the final goal state.
Limitations
This paper presents a multi-objective curricula learning approach for solving challenging deep robotics tasks.
However, it may be interesting to improve the sample efficiency of policy learning.
Our method utilizes bi-level optimization, which elongates the training efficiency in terms of interactions between robots and environments.
We argue that this limitation could be largely alleviated by replacing the model-free policy learning method with the model-based policy learning method. A Appendix A.1 Environment Settings
We choose five out of the nine tasks introduced in CausalWorld since the other four tasks have limited support for configuring the initial and goal states.
Specifically, we enumerate these five tasks here: (1) Reaching requires moving a robotic arm to a goal position and reach a goal block; (2) Pushing requires pushing one block towards a goal position with a specific orientation (restricted to goals on the floor level); (3) Picking requires picking one block at a goal height above the center of the arena (restricted to goals above the floor level); (4) Pick And Place is an arena is divided by a fixed long block and the goal is to pick one block from one side of the arena to a goal position with a variable orientation on the other side of the fixed block;
(5) Stacking requires stacking two blocks above each other in a specific goal position and orientation.
CausalWorld allows us to easily modify the initial states and goal states.
In general, the initial state is the cylindrical position and Euler orientation of the block and goal state is the position variables of the goal block.
These two control variables are both three-dimensional vectors with a fixed manipulation range.
To match the range of each vector, we re-scale the generated initial states.
The reward function defined in CausalWorld is uniform across all possible goal shapes as the fractional volumetric overlap of the blocks with the goal shape, which ranges between 0 (no overlap) and(complete overlap).
We also re-scale the shaping reward to match this range.
We choose the PPO algorithm as our vanilla DRL policy learning method.
We list the important hyper-parameters in Table.
We also provide the complete code in the supplementary material.
[Table]
[Figure]
[Table]
[Figure]
e a n e p
i s o d e r e w a r d
[Figure]
A.2 Curricula Analysis and Visualization
In this section, we analyze the initial state curriculum and goal state curriculum.
First, we replace the initial state curriculum with two different alternatives: (1) MOC RandInitState , in which we replace the initial state curriculum in MOC with a uniformly chosen state.
Other MOC components remains the same; (2) MOC FixInitState , in which we replace the initial state curriculum in MOC with
a fixed
[Table]
initial state.
The other MOC components remains the same.
(3) MOC RandGoalState , in which we replace the goal state curriculum in MOC with a uniformly chosen state.
The other MOC components remains the same.
The evaluations are conducted on the reaching task and the results are shown in Table 2a.
From this table, we observe that MOC with initial state curriculum outperforms other two baseline schemes in terms of mean episode rewards and success ratio.
This demonstrates the effectiveness of providing initial state curriculum.
Besides, since “random sampling” outperforms “fixed initial state”, we conjecture that it is better to provide different initial states, which might be beneficial for exploration.
In Sec. 5.
[Table]
we show that providing multi-objective curricula can improve the training of DRL agents.
To further evaluate the advantages of hyper-RNN base-RNN framework
[Table]
we conduct an experiment with GoalGAN, ALP-GMM and MOC with goal curriculum only.
We evaluate on reaching task and the results are shown in Tab. 2b.
In this table, we see that MOC Goal State (MOC Memory − ,Goal + ), which is MOC has goal curriculum but doesn’t have memory component, slightly outperform other two baseline schemes.
A.3 Additional Experimental Results
This section serves as a supplementary results for Sec. 5.
Fig.
5 shows the results of with and without Hyper-RNN in pushing tasks.
The results validate the effectiveness of using Hyper-RNN.
It is clear that, the incorporation of memory module consistently helps the DRL agent outperform other strong baselines in all scenarios.
More importantly, in pushing task, we can observe a 5-fold improvement compared to the method with only the Hyper-RNN component.
Fig.
5 clearly validate the effectiveness of our proposed method in achieving both the best final performance and improving sample efficiency.
A.4 Additional Visualizations of States
Figs. 6, 7, 8, 9 visualize the state visitation density in task reaching , picking , pushing and pick and place , respectively.
From these results, we summarize the following observations: (1) The proposed architecture can help the agent explore different state spaces, which can be seen in the top row and bottom row.
The ablation study with three independent curricula often leads to exploring three different state space, as shown in Fig.
7 and Fig.
By adding a memory component, the proposed MOC DRL can effectively utilize all curricula and help the agent focus on one specific state space.
This is the reason why the proposed MOC DRL outperforms the other baselines in all tasks.
(4) Comparing with Hyper-RNN (”no-mem”) and without Hyper-RNN (”independent”), we can see that one of the benefits of using Hyper-RNN is aggregating different curricula.
These can also be found in Fig.and Fig. 8.
[Figure]
Pushing
[Figure]
[Figure]
[Figure]
[Figure]
A.5 Additional Experiment Results
In Sec. 5.
[Figure]
we compared MOC with state-of-the art ACL algorithms.
Here, we add two more baselines algorithms.
The results are shown in Fig.
• InitailGAN [6]: which generates adapting initial states for the agent to start with.
• PPO Reward + : which is a DRL agent trained with PPO algorithm and reward shaping.
The shaping function is instantiated as a deep neural network.
A.6 PPO Modifications
In Sec.
[Figure]
we propose a MOC-DRL framework for actor-critic algorithms.
Since we adopt PPO in this paper, we now describe how we modify the PPO to cope with the learned curricula.
We aim to maximize the PPO-clip objective:
[Equation]
where
[Equation]
where θ is the parameter of policy π , θ k is the updated k step parameter by taking the objective above,
A is the advantage function that we define as:
[Figure]
[Figure]
a n e p
i s o d e r
[Figure]
w a r d
[Figure]
[Equation]
For the Hyper-RNN training, we modify the Q function as Q ( s, a, c goal , c rew , c ini , c abs ) .
A.7 Bilevel Training
Here we provide more details regarding the bilevel training of Hyper-RNN introduced in Sec. 4.3.
The optimal parameters θ ∗ h are obtained by minimizing the loss function J outer .
The key steps can be summarized as:
Step 1 Update PPO agent parameters θ on one sampled task by Eqn.
Step 2 With updated parameters θ , we train model parameters θ h via SGD by minimizing the outer loss function θ ∗ h = argmin
θ h J
outer .
Step 3 With θ h , we generate manually designed curricula and abstract curriculum.
{+Step 
+}
We give the generate curriculum to the Q function and environment hyper-parameters.
{+Step 
+}
We go back to Step 1 for agent training until converge.
A.8 Hyper-net
[14] introduce to generate parameters of Recurrent Networks using another neural networks.
This approach is to put a small RNN cell (called the Hyper-RNN cell) inside a large RNN cell (the main RNN).
The Hyper-RNN cell will have its own hidden units and its own input sequence.
The input sequence for the Hyper-RNN cell will be constructed from 2 sources: the previous hidden
[Figure]
a c t i o n a l
[Figure]
cc
[Figure]
[Figure]
n
[Figure]
i s
[Figure]
d
[Figure]
r
[Figure]
w a r d
[Figure]
states of the main LSTM concatenated with the actual input sequence of the main LSTM.
The outputs of the Hyper-RNN cell will be the embedding vector Z that will then be used to generate the weight matrix for the main LSTM.
Unlike generating weights for convolutional neural networks, the weight-generating embedding vectors are not kept constant, but will be dynamically generated by the
HyperLSTM cell.
This allows the model to generate a new set of weights at each time step and for each input example.
The standard formulation of a basic RNN is defined as:
[Equation]
where h t is the hidden state, ϕ is a non-linear operation such as tanh or relu , and the weight matrics and bias W h ∈ R
N
h
× N h , W x ∈ R N h
× N x , b ∈
R N h is fixed each timestep for an input sequence
X = ( x 1 , . . .
, x T ) .
More conceretly, the parameters W h , W x , b of the main RNN are different at different time steps, so that h t can now be computed as:
[Equation]
where
[Equation]
{+8 Episodes 1e
+}
M e a n e p
i s o d e r e w a r d
{+Reaching    8 Episodes 1e
+}
{+Picking    8 Episodes 1e
+}
Pushing    8 Episodes 1e
M e a n r p
i s o d e r e w a r d
Pick_and_Place    8 Episodes 1e
Stacking
[Figure]
+
[Figure]
where W hz ∈ R N h
×
N h × N z ,
W xz ∈ R N h
× N x × N z , W bz ∈ R N h
× N z , b o ∈ R N h and z h , z x , z z ∈ R N z .
Moreover, z h , z x and z b can be computed as a function of x t and h t − 1 :
[Equation]
Where W ˆ h ∈ R N ˆ h × N
ˆ
h , W ˆ x ∈ R
N ˆ h × ( N h + N z ) , b ∈ R N ˆ h , and W ˆ hh ,
W ˆ hx , W ˆ hb ∈ R N z
× N ˆ h
and ˆ b ˆ hh , ˆ b ˆ hx ∈ R N z .
The Hyper-RNN cell has N ˆ h hidden units.
A.9 The abstract curriculum training
For some difficult tasks, we find that it is difficult to train a policy with small variances if the
Hyper-RNN is initialized with random parameters 3 .
As a simple workaround, we propose to pre-train the Hyper-RNN and memory components in a slightly unrelated task.
In particular, when solving task T x , we pre-train the abstract memory module on tasks other than T x .
A.10 The visualization of generated sub-goal
The visualization of generated sub-goal state is shown in Fig.
Specifically, the arm is tasked to manipulate the red cube to the position shown as a green cube.
As we can see, MOC generates subgoals that gradually change from ”easy” (which are close to the initial state) to ”hard” (which are close to the goal state).
The generated subgoals have different configurations ( e.g. , the green cube is headed north-west in 7000k steps but is headed north-east in 9000k steps ), which requires the agent to learn to delicately manipulate robot arm.
A.11 Hyperparameters
In this section, we extensively evaluate the influence of different hyperparameters for the baselines and MOC, where the search is done with random search.
We choose the reaching and stacking tasks, which are shown in Fig.
For example, in Fig.
15-(a), the first column represents the
[Figure]
different values for outer iterations.
A particular horizontal line, e.g. , { 4 , 512 , 5 , 0 . 5 } , indicates a particular set of hyperparameters for one experiment.
Besides, during the training phase, we adopt hyperparameters of PPO from stable-baselines3 and search two hyperparameters to test the MOC sensitivity.
We can observe that: (1) It is clear that MOC outperforms all the baselines with extensive hyperparameter search.
(2) MOC is not sensitive to different hyperparameters.
[Figure]
[Figure]
[Figure]
[Figure]
−
[Figure]
−
[Figure]
−
[Figure]
−
[Figure]
− −
[Figure]
−
[Figure]
−
[Figure]
[Figure]
[Figure]