Title: SUB-POLICY ADAPTATION FOR HIERARCHICAL REINFORCEMENT LEARNING

Abstract: Hierarchical reinforcement learning is a promising approach to tackle long-horizon decision-making problems with sparse rewards. Unfortunately, most methods still decouple the lower-level skill acquisition process and the training of a higher level that controls the skills in a new task. Leaving the skills fixed can lead to significant sub-optimality in the transfer setting. In this work, we propose a novel algorithm to discover a set of skills and continuously adapt them along with the higher level even when training on a new task. Our main contributions are two-fold. First, we derive a new hierarchical policy gradient with an unbiased latent-dependent baseline, and we introduce Hierarchical Proximal Policy Optimization (HiPPO), an on-policy method to efficiently train all levels of the hierarchy jointly. Second, we propose a method of training time-abstractions that improves the robustness of the obtained skills to environment changes. Code and videos are available. 1 .

1. INTRODUCTION:

Reinforcement learning (RL) has made great progress in a variety of domains, from playing games such as Pong and Go (Mnih et al., 2015; Silver et al., 2017) to automating robotic locomotion (Schulman et al., 2015; Heess et al., 2017) , dexterous manipulation (Florensa et al., 2017b; OpenAI et al., 2018) , and perception (Nair et al., 2018; Florensa et al., 2018 ). Yet, most work in RL is still learning from scratch when faced with a new problem. This is particularly inefficient when tackling multiple related tasks that are hard to solve due to sparse rewards or long horizons.

A promising technique to overcome this limitation is hierarchical reinforcement learning (HRL) (Sutton et al., 1999) . In this paradigm, policies have several modules of abstraction, allowing to reuse subsets of the modules. The most common case consists of temporal hierarchies (Precup, 2000; Dayan & Hinton, 1993) , where a higher-level policy (manager) takes actions at a lower frequency, and its actions condition the behavior of some lower level skills or sub-policies. When transferring knowledge to a new task, most prior works fix the skills and train a new manager on top. Despite having a clear benefit in kick-starting the learning in the new task, having fixed skills can considerably cap the final performance on the new task (Florensa et al., 2017a) . Little work has been done on adapting pre-trained sub-policies to be optimal for a new task.

In this paper, we develop a new framework for simultaneously adapting all levels of temporal hierarchies. First, we derive an efficient approximated hierarchical policy gradient. The key insight is that, despite the decisions of the manager being unobserved latent variables from the point of view of the Markovian environment, from the perspective of the sub-policies they can be considered as part of the observation. We show that this provides a decoupling of the manager and sub-policy gradients, which greatly simplifies the computation in a principled way. It also theoretically justifies a technique used in other prior works (Frans et al., 2018) . Second, we introduce a sub-policy specific baseline for our hierarchical policy gradient. We prove that this baseline is unbiased, and our experiments reveal faster convergence, suggesting efficient gradient variance reduction. Then, we introduce a more stable way of using this gradient, Hierarchical Proximal Policy Optimization (HiPPO). This method helps us take more conservative steps in our policy space (Schulman et al., 2017) , critical in hierarchies because of the interdependence of each layer. Results show that HiPPO is highly efficient both when learning from scratch, i.e. adapting randomly initialized skills, and when adapting pretrained skills on a new task. Finally, we evaluate the benefit of randomizing the time-commitment of the sub-policies, and show it helps both in terms of final performance and zero-shot adaptation on similar tasks.

2. PRELIMINARIES:

Figure 1 : Temporal hierarchy studied in this paper. A latent code z t is sampled from the manager policy π θ h (z t |s t ) every p time-steps, using the current observation s kp . The actions a t are sampled from the sub-policy π θ l (a t |s t , z kp ) conditioned on the same latent code from t = kp to (k + 1)p -1

We define a discrete-time finitehorizon discounted Markov decision process (MDP) by a tuple M = (S, A, P, r, ρ 0 , γ, H), where S is a state set, A is an action set, P : S × A × S → R + is the transition probability distribution, γ ∈ [0, 1] is a discount factor, and H the horizon. Our objective is to find a stochastic policy π θ that maximizes the expected discounted return within the MDP,

η(π θ ) = E τ [ H t=0 γ t r(s t , a t )].

We use τ = (s 0 , a 0 , ..., ) to denote the entire state-action trajectory, where s 0 ∼ ρ 0 (s 0 ), a t ∼ π θ (a t |s t ), and s t+1 ∼ P(s t+1 |s t , a t ).

In this work, we propose a method to learn a hierarchical policy and efficiently adapt all the levels in the hierarchy to perform a new task. We study hierarchical policies composed of a higher level, or manager π θ h (z t |s t ), and a lower level, or sub-policy π θ l (a t |z t , s t ). The higher level does not take actions in the environment directly, but rather outputs a command, or latent variable z t ∈ Z, that conditions the behavior of the lower level. We focus on the common case where Z = Z n making the manager choose among n sub-policies, or skills, to execute. The manager typically operates at a lower frequency than the sub-policies, only observing the environment every p time-steps. When the manager receives a new observation, it decides which low level policy to commit to for p environment steps by the means of a latent code z. Figure 1 depicts this framework where the high level frequency p is a random variable, which is one of the contribution of this paper as described in Section 4.4. Note that the class of hierarchical policies we work with is more restrictive than others like the options framework, where the time-commitment is also decided by the policy. Nevertheless, we show that this loss in policy expressivity acts as a regularizer and does not prevent our algorithm from surpassing other state-of-the art methods.

3. RELATED WORK:

There has been growing interest in HRL for the past few decades (Sutton et al., 1999; Precup, 2000) , but only recently has it been applied to high-dimensional continuous domains as we do in this work (Kulkarni et al., 2016; Daniel et al., 2016) . To obtain the lower level policies, or skills, most methods exploit some additional assumptions, like access to demonstrations (Le et al., 2018; Merel et al., 2019; Ranchod et al., 2015; Sharma et al., 2018) , policy sketches (Andreas et al., 2017) , or task decomposition into sub-tasks (Ghavamzadeh & Mahadevan, 2003; Sohn et al., 2018) . Other methods use a different reward for the lower level, often constraining it to be a "goal reacher" policy, where the signal from the higher level is the goal to reach (Nachum et al., 2018; Levy et al., 2019; Vezhnevets et al., 2017) . These methods are very promising for state-reaching tasks, but might require access to goal-reaching reward systems not defined in the original MDP, and are more limited when training on tasks beyond state-reaching. Our method does not require any additional supervision, and the obtained skills are not constrained to be goal-reaching.

When transferring skills to a new environment, most HRL methods keep them fixed and simply train a new higher-level on top (Hausman et al., 2018; Heess et al., 2016) . Other work allows for building on previous skills by constantly supplementing the set of skills with new ones (Shu et al., 2018) , but they require a hand-defined curriculum of tasks, and the previous skills are never fine-tuned.

Our algorithm allows for seamless adaptation of the skills, showing no trade-off between leveraging the power of the hierarchy and the final performance in a new task. Other methods use invertible functions as skills (Haarnoja et al., 2018) , and therefore a fixed skill can be fully overwritten when a new layer of hierarchy is added on top. This kind of "fine-tuning" is promising, although similar to other works (Peng et al., 2019) , they do not apply it to temporally extended skills as we do here.

One of the most general frameworks to define temporally extended hierarchies is the options framework (Sutton et al., 1999) , and it has recently been applied to continuous state spaces (Bacon et al., 2017) . One of the most delicate parts of this formulation is the termination policy, and it requires several regularizers to avoid skill collapse (Harb et al., 2017; Vezhnevets et al., 2016) . This modification of the objective may be difficult to tune and affects the final performance. Instead of adding such penalties, we propose to have skills of a random length, not controlled by the agent during training of the skills. The benefit is two-fold: no termination policy to train, and more stable skills that transfer better. Furthermore, these works only used discrete action MDPs. We lift this assumption, and show good performance of our algorithm in complex locomotion tasks. There are other algorithms recently proposed that go in the same direction, but we found them more complex, less principled (their per-action marginalization cannot capture well the temporal correlation within each option), and without available code or evidence of outperforming non-hierarchical methods (Smith et al., 2018) .

The closest work to ours in terms of final algorithm structure is the one proposed by Frans et al. (2018) . Their method can be included in our framework, and hence benefits from our new theoretical insights. We introduce a modification that is shown to be highly beneficial: the random timecommitment mentioned above, and find that our method can learn in difficult environments without their complicated training scheme.

4. EFFICIENT HIERARCHICAL POLICY GRADIENTS:

When using a hierarchical policy, the intermediate decision taken by the higher level is not directly applied in the environment. Therefore, technically it should not be incorporated into the trajectory description as an observed variable, like the actions. This makes the policy gradient considerably harder to compute. In this section we first prove that, under mild assumptions, the hierarchical policy gradient can be accurately approximated without needing to marginalize over this latent variable. Then, we derive an unbiased baseline for the policy gradient that can reduce the variance of its estimate. Finally, with these findings, we present our method, Hierarchical Proximal Policy Optimization (HiPPO), an on-policy algorithm for hierarchical policies, allowing learning at all levels of the policy jointly and preventing sub-policy collapse.

4.1. APPROXIMATE HIERARCHICAL POLICY GRADIENT:

Policy gradient algorithms are based on the likelihood ratio trick (Williams, 1992) to estimate the gradient of returns with respect to the policy parameters as

EQUATION

In a temporal hierarchy, a hierarchical policy with a manager π θ h (z t |s t ) selects every p time-steps one of n sub-policies to execute. These sub-policies, indexed by z ∈ Z n , can be represented as a single conditional probability distribution over actions π θ l (a t |z t , s t ). This allows us to not only use a given set of sub-policies, but also leverage skills learned with Stochastic Neural Networks (SNNs) (Florensa et al., 2017a) . Under this framework, the probability of a trajectory τ = (s 0 , a 0 , s 1 , . . . , s H ) can be written as

P (τ ) = H/p k=0 n j=1 π θ h (z j |s kp ) (k+1)p-1 t=kp π θ l (a t |s t , z j ) P (s 0 ) H t=1 P (s t+1 |s t , a t ) . (3)

The mixture action distribution, which presents itself as an additional summation over skills, prevents additive factorization when taking the logarithm, as from Eq. 1 to 2. This can yield numerical instabilities due to the product of the p sub-policy probabilities. For instance, in the case where all the skills are distinguishable all the sub-policies' probabilities but one will have small values, resulting in an exponentially small value. In the following Lemma, we derive an approximation of the policy gradient, whose error tends to zero as the skills become more diverse, and draw insights on the interplay of the manager actions. Lemma 1. If the skills are sufficiently differentiated, then the latent variable can be treated as part of the observation to compute the gradient of the trajectory probability. Let π θ h (z|s) and π θ l (a|s, z) be Lipschitz functions w.r.t. their parameters, and assume that 0 < π θ l (a|s, z j ) < ∀j = kp, then

EQUATION

Proof. See Appendix.

Our assumption can be seen as having diverse skills. Namely, for each action there is just one sub-policy that gives it high probability. In this case, the latent variable can be treated as part of the observation to compute the gradient of the trajectory probability. Many algorithms to extract lowerlevel skills are based on promoting diversity among the skills (Florensa et al., 2017a; Eysenbach et al., 2019) , therefore usually satisfying our assumption. We further analyze how well this assumption holds in our experiments section and Table 2 .

4.2. UNBIASED SUB-POLICY BASELINE:

The policy gradient estimate obtained when applying the log-likelihood ratio trick as derived above is known to have large variance. A very common approach to mitigate this issue without biasing the estimate is to subtract a baseline from the returns (Peters & Schaal, 2008) . It is well known that such baselines can be made state-dependent without incurring any bias. However, it is still unclear how to formulate a baseline for all the levels in a hierarchical policy, since an action dependent baseline does introduce bias in the gradient (Tucker et al., 2018) . It has been recently proposed to use latent-conditioned baselines (Weber et al., 2019) . Here we go further and prove that, under the assumptions of Lemma 1, we can formulate an unbiased latent dependent baseline for the approximate gradient (Eq. 5). Lemma 2. For any functions b h : S → R and b l : S × Z → R we have:

E τ [ H/p k=0 ∇ θ log P (z kp |s kp )b h (s kp )] = 0 and E τ [ H t=0 ∇ θ log π θ l (a t |s t , z kp )b l (s t , z kp )] = 0

Proof. See Appendix.

Now we apply Lemma 1 and Lemma 2 to Eq. 1. By using the corresponding value functions as the function baseline, the return can be replaced by the Advantage function A(s kp , z kp ) (see details in Schulman et al. ( 2016)), and we obtain the following approximate policy gradient expression:

ĝ = E τ ( H/p k=0 ∇ θ log π θ h (z kp |s kp )A(s kp , z kp )) + ( H t=0 ∇ θ log π θ l (a t |s t , z kp )A(s t , a t , z kp ))

This hierarchical policy gradient estimate can have lower variance than without baselines, but using it for policy optimization through stochastic gradient descent still yields an unstable algorithm. In the next section, we further improve the stability and sample efficiency of the policy optimization by incorporating techniques from Proximal Policy Optimization (Schulman et al., 2017) .

4.3. HIERARCHICAL PROXIMAL POLICY OPTIMIZATION:

Using an appropriate step size in policy space is critical for stable policy learning. Modifying the policy parameters in some directions may have a minimal impact on the distribution over actions, whereas small changes in other directions might change its behavior drastically and hurt training θ ← θ + α∇ θ L CLIP HiP P O (θ) 8: end while efficiency (Kakade, 2002) . Trust region policy optimization (TRPO) uses a constraint on the KLdivergence between the old policy and the new policy to prevent this issue (Schulman et al., 2015) . Unfortunately, hierarchical policies are generally represented by complex distributions without closed form expressions for the KL-divergence. Therefore, to improve the stability of our hierarchical policy gradient we turn towards Proximal Policy Optimization (PPO) (Schulman et al., 2017) . PPO is a more flexible and compute-efficient algorithm. In a nutshell, it replaces the KL-divergence constraint with a cost function that achieves the same trust region benefits, but only requires the computation of the likelihood. Letting w t (θ) = π θ (at|st) π θ old (at|st) , the PPO objective is:

L CLIP (θ) = E t min w t (θ)A t , clip(w t (θ), 1 -, 1 + )A t

We can adapt our approximated hierarchical policy gradient with the same approach by letting w h,kp (θ) = min w l,t (θ)A(s t , a t , z kp ), w clip l,t (θ)A(s t , a t , z kp )

We call this algorithm Hierarchical Proximal Policy Optimization (HiPPO). Next, we introduce a critical additions: a switching of the time-commitment between skills.

4.4. VARYING TIME-COMMITMENT:

Most hierarchical methods either consider a fixed time-commitment to the lower level skills (Florensa et al., 2017a; Frans et al., 2018) , or implement the complex options framework (Precup, 2000; Bacon et al., 2017) . In this work we propose an in-between, where the time-commitment to the skills is a random variable sampled from a fixed distribution Categorical(T min , T max ) just before the manager takes a decision. This modification does not hinder final performance, and we show it improves zero-shot adaptation to a new task. This approach to sampling rollouts is detailed in Algorithm 1. The full algorithm is detailed in Algorithm 2.

5. EXPERIMENTS:

We designed our experiments to answer the following questions: 1) How does HiPPO compare against a flat policy when learning from scratch? 2) Does it lead to policies more robust to environment changes? 3) How well does it adapt already learned skills? and 4) Does our skill diversity assumption hold in practice? 

5.1. TASKS:

We evaluate our approach on a variety of robotic locomotion and navigation tasks. The Block environments, depicted in Fig. 2a -2b, have walls of random heights at regular intervals, and the objective is to learn a gait for the Hopper and Half-Cheetah robots to jump over them. The agents observe the height of the wall ahead and their proprioceptive information (joint positions and velocities), receiving a reward of +1 for each wall cleared. The Gather environments, described by Duan et al. (2016) , require agents to collect apples (green balls, +1 reward) while avoiding bombs (red balls, -1 reward). The only available perception beyond proprioception is through a LIDAR-type sensor indicating at what distance are the objects in different directions, and their type, as depicted in the bottom left corner of Fig. 2c-2d . This is challenging hierarchical task with sparse rewards that requires simultaneously learning perception, locomotion, and higher-level planning capabilities. We use the Snake and Ant robots in Gather. Details for all robotic agents are provided in Appendix B.

5.2. LEARNING FROM SCRATCH AND TIME-COMMITMENT:

In this section, we study the benefit of using our HiPPO algorithm instead of standard PPO on a flat policy (Schulman et al., 2017) . The results, reported in Figure 3 , demonstrate that training from scratch with HiPPO leads to faster learning and better performance than flat PPO. Furthermore, we show that the benefit of HiPPO does not just come from having temporally correlated exploration: PPO with action repeat converges at a lower performance than our method. HiPPO leverages the time-commitment more efficiently, as suggested by the poor performance of the ablation where we set p = 1, when the manager takes an action every environment step as well. Finally, Figure 4 shows the effectiveness of using the presented skill-dependent baseline.

5.3. COMPARISON TO OTHER METHODS:

We compare HiPPO to current state-of-the-art hierarchical methods. First, we evaluate HIRO (Nachum et al., 2018) , an off-policy RL method based on training a goal-reaching lower level policy. Fig. 5 shows that HIRO achieves poor performance on our tasks. As further detailed in Appendix D, this algorithm is sensitive to access to ground-truth information, like the exact (x, y) position of the robot in Gather. In contrast, our method is able to perform well directly from the raw sensory inputs described in Section 5.1. We evaluate Option-Critic (Bacon et al., 2017) , a variant of the options framework (Sutton et al., 1999) that can be used for continuous action-spaces. It fails to learn, and we hypothesize that their algorithm provides less time-correlated exploration and learns less diverse skills. We also compare against MLSH (Frans et al., 2018) , which repeatedly samples new environment configurations to learn primitive skills. We take these hyperparameters from their Ant Twowalk experiment: resetting the environment configuration every 60 iterations, a warmup period of 20 during which only the manager is trained, and a joint training period of 40 during which both manager and skills are trained. Our results show that such a training scheme does not provide any benefits. Finally, we provide a comparison to a direct application of our Hierarchical Vanilla Policy Gradient (HierVPG) algorithm, and we see that the algorithm is unstable without PPO's trust-region-like technique.

5.4. ROBUSTNESS TO DYNAMICS PERTURBATIONS:

We investigate the robustness of HiPPO to changes in the dynamics of the environment. We perform several modifications to the base Snake Gather and Ant Gather environments. One at a time, we change the body mass, dampening of the joints, body inertia, and friction characteristics of both robots. The results, presented in Table 1 , show that HiPPO with randomized period Categorical([T min , T max ]) is able to better handle these dynamics changes. In terms of the drop in policy performance between the training environment and test environment, it outperforms HiPPO with fixed period on 6 out of 8 related tasks. These results suggest that the randomized period exposes the policy to a wide range of scenarios, which makes it easier to adapt when the environment changes. 12% )

Gather:

Table 1 : Zero-shot transfer performance. The final return in the initial environment is shown, as well as the average return over 25 rollouts in each new modified environment.

5.5. ADAPTATION OF PRE-TRAINED SKILLS:

For the Block task, we use DIAYN (Eysenbach et al., 2019) to train 6 differentiated subpolicies in an environment without any walls. Here, we see if these diverse skills can improve performance on a downstream task that's out of the training distribution. For Gather, we take 6 pretrained subpolicies encoded by a Stochastic Neural Network (Tang & Salakhutdinov, 2013) that was trained in a diversity-promoting environment (Florensa et al., 2017a) . We fine-tune them with HiPPO on the Gather environment, but with an extra penalty on the velocity of the Center of Mass. This can be understood as a preference for cautious behavior. This requires adjustment of the sub-policies, which were trained with a proxy reward encouraging them to move as far as possible (and hence quickly). Fig. 6 shows that using HiPPO to simultaneously train a manager and fine-tune the skills achieves higher final performance than fixing the sub-policies and only training a manager with PPO. The two initially learn at the same rate, but HiPPO's ability to adjust to the new dynamics allows it to reach a higher final performance. Fig. 6 also shows that HiPPO can fine-tune the same given skills better than Option-Critic (Bacon et al., 2017) , MLSH (Frans et al., 2018) , and HIRO (Nachum et al., 2018) .

5.6. SKILL DIVERSITY ASSUMPTION:

In Lemma 1, we derived a more efficient and numerically stable gradient by assuming that the sub-policies are diverse. In this section, we empirically test the validity of our assumption and the quality of our approximation. We run the HiPPO algorithm on Ant Gather and Snake Gather both from scratch and with given pretrained skills, as done in the previous section. In Table 2 , we report the average maximum probability under other sub-policies, corresponding to from the assumption. In all settings, this is on the order of magnitude of 0.1. Therefore, under the p ≈ 10 that we use in our experiments, the term we neglect has a factor p-1 = 10 -10 . It is not surprising then that the average cosine similarity between the full gradient and our approximation is almost 1, as reported in 2 : Empirical evaluation of Lemma 1. In the middle and right columns, we evaluate the quality of our assumption by computing the largest probability of a certain action under other skills ( ), and the action probability under the actual latent. We also report the cosine similarity between our approximate gradient and the exact gradient from Eq. 3. The mean and standard deviation of these values are computed over the full batch collected at iteration 10.

A HYPERPARAMETERS AND ARCHITECTURES:

The Block environments used a horizon of 1000 and a batch size of 50,000, while Gather used a batch size of 100,000. Ant Gather has a horizon of 5000, while Snake Gather has a horizon of 8000 due to its larger size. For all experiments, both PPO and HiPPO used learning rate 3 × 10 -3 , clipping parameter = 0.1, 10 gradient updates per iteration, and discount γ = 0.999. The learning rate, clipping parameter, and number of gradient updates come from the OpenAI Baselines implementation.

HiPPO used n = 6 sub-policies. HiPPO uses a manager network with 2 hidden layers of 32 units, and a skill network with 2 hidden layers of 64 units. In order to have roughly the same number of parameters for each algorithm, flat PPO uses a network with 2 hidden layers with 256 and 64 units respectively. For HiPPO with randomized period, we resample p ∼ Uniform{5, 15} every time the manager network outputs a latent, and provide the number of timesteps until the next latent selection as an input into both the manager and skill networks. The single baselines and skill-dependent baselines used a MLP with 2 hidden layers of 32 units to fit the value function. The skill-dependent baseline receives, in addition to the full observation, the active latent code and the time remaining until the next skill sampling. All runs used five random seeds.

B ROBOT AGENT DESCRIPTION:

Hopper is a 3-link robot with a 14-dimensional observation space and a 3-dimensional action space.

Half-Cheetah has a 20-dimensional observation space and a 6-dimensional action space. We evaluate both of these agents on a sparse block hopping task. In addition to observing their own joint angles and positions, they observe the height and length of the next wall, the x-position of the next wall, and the distance to the wall from the agent. We also provide the same wall observations for the previous wall, which the agent can still interact with. Snake is a 5-link robot with a 17-dimensional observation space and a 4-dimensional action space. Ant is a quadrupedal robot with a 27-dimensional observation space and a 8-dimensional action space. Both Ant and Snake can move and rotate in all directions, and Ant faces the added challenge of avoiding falling over irrecoverably. In the Gather environment, agents also receive 2 sets of 10-dimensional lidar observations, whcih correspond to separate apple and bomb observations. The observation displays the distance to the nearest apple or bomb in each 36 • bin, respectively. All environments are simulated with the physics engine MuJoCo (Todorov et al., 2012) .

C PROOFS Lemma 1. If the skills are sufficiently differentiated, then the latent variable can be treated as part of the observation to compute the gradient of the trajectory probability. Concretely, if π θ h (z|s) and π θ l (a|s, z) are Lipschitz in their parameters, and 0 < π θ l (a t |s t , z j ) < ∀j = kp, then

EQUATION

Proof. From the point of view of the MDP, a trajectory is a sequence τ = (s 0 , a 0 , s 1 , a 1 , . . . , a H-1 , s H ). Let's assume we use the hierarchical policy introduced above, with a higher-level policy modeled as a parameterized discrete distribution with n possible outcomes π θ h (z|s) = Categorical θ h (n). We can expand P (τ ) into the product of policy and environment dynamics terms, with z j denoting the jth possible value out of the n choices,

P (τ ) = H/p k=0 n j=1 π θ h (z j |s kp ) (k+1)p-1 t=kp π θ l (a t |s t , z j ) P (s 0 ) H t=1 P (s t+1 |s t , a t )

Taking the gradient of log P (τ ) with respect to the policy parameters θ = [θ h , θ l ], the dynamics terms disappear, leaving:

∇ θ log P (τ ) = H/p k=0 ∇ θ log n j=1 π θ l (z j |s kp ) (k+1)p-1 t=kp π s,θ (a t |s t , z j ) = H/p k=0 1 n j=1 π θ h (z j |s kp ) (k+1)p-1 t=kp π θ l (a t |s t , z j ) n j=1 ∇ θ π θ h (z j |s kp ) (k+1)p-1 t=kp π θ l (a t |s t , z j )

The sum over possible values of z prevents the logarithm from splitting the product over the p-step sub-trajectories. This term is problematic, as this product quickly approaches 0 as p increases, and suffers from considerable numerical instabilities. Instead, we want to approximate this sum of products by a single one of the terms, which can then be decomposed into a sum of logs. For this we study each of the terms in the sum: the gradient of a sub-trajectory probability under a specific latent ∇ θ π θ h (z j |s kp ) (k+1)p-1 t=kp π θ l (a t |s t , z j ) . Now we can use the assumption that the skills are easy to distinguish, 0 < π θ l (a t |s t , z j ) < ∀j = kp. Therefore, the probability of the sub-trajectory under a latent different than the one that was originally sampled z j = z kp , is upper bounded by p . Taking the gradient, applying the product rule, and the Lipschitz continuity of the policies, we obtain that for all z j = z kp , Interestingly, this is exactly ∇ θ P (s 0 , z 0 , a 0 , s 1 , . . . ). In other words, it's the gradient of the probability of that trajectory, where the trajectory now includes the variables z as if they were observed. Then, we can write out the definition of the expectation and undo the gradient-log trick to prove that the baseline is unbiased.

EQUATION

E 

:

CONCLUSIONS AND FUTURE WORKIn this paper, we examined how to effectively adapt temporal hierarchies. We began by deriving a hierarchical policy gradient and its approximation. We then proposed a new method, HiPPO, that can stably train multiple layers of a hierarchy jointly. The adaptation experiments suggest that we can optimize pretrained skills for downstream environments, and learn emergent skills without any unsupervised pre-training. We also demonstrate that HiPPO with randomized period can learn from scratch on sparse-reward and long time horizon tasks, while outperforming non-hierarchical methods on zero-shot transfer.

Figures and Tables:

θ h (z kp |s kp ) π θ h,old (z kp |s kp ) and w l,t (θ) = π θ l (at|st,z kp ) π θ l,old (at|st,z kp ) , and using the super-index clip to denote the clipped objective version, we obtain the new surrogate objective: L CLIP HiP P O (θ) = E τ H/p k=0 min w h,kp (θ)A(s kp , z kp ), w clip h,kp (θ)A(s kp , z kp ) + H t=0

Figure 2: Environments used to evaluate the performance of our method. Every episode has a different configuration: wall heights for (a)-(b), ball positions for (c)-(d)

Figure 4: Using a skill-conditioned baseline, as defined in Section 4.2, generally improves performance of HiPPO when learning from scratch.

Figure 6: Benefit of adapting some given skills when the preferences of the environment are different from those of the environment where the skills were originally trained. Adapting skills with HiPPO has better learning performance than leaving the skills fixed or learning from scratch.

For any functions b h : S → R and b l : S × Z → R we have:E τ [ H/p k=0 ∇ θ log P (z kp |s kp )b(s kp )] = 0 E τ [ H t=0 ∇ θ log π θ l (a t |s t , z kp )b(s t , z kp )] = 0Proof. We can use the tower property as well as the fact that the interior expression only depends on s kp and z kp : θ log P (z kp |s kp )b(s kp )] = H/p k=0 E s kp ,z kp [E τ \s kp ,z kp [∇ θ log P (z kp |s kp )b(s kp )s kp ,z kp [∇ θ log P (z kp |s kp )b(s kp )]

Algorithm 1 HiPPO Rollout 1: Input: skills π θ l (a|s, z), manager π θ h (z|s), timecommitment bounds P min and P max , horizon H 2: Reset environment:s 0 ∼ ρ 0 , t = 0. Sample skill z t ∼ π θ h (•|s t )Sample action a t ∼ π θ l (•|s t , z t ) Output: (s 0 , z 0 , a 0 , s 1 , a 1 , . . . , s H , z H , a H , s H+1 ) Input: skills π θ l (a|s, z), manager π θ h (z|s), horizon H, learning rate α 2: while not done do , s t , z t ) and Â(z t , s t )

Table content: <table><tr><td>3: while t &lt; H do 4: Sample time-commitment p ∼ Cat([P min , P max ]) 5: 6: for t = t . . . (t + p) do 7: 8: Observe new state s t +1 and reward r t 9: end for 10: t ← t + p 11: end while 12: Algorithm 2 HiPPO 13: for actor = 1, 2, ..., N do 4: Obtain trajectory with HiPPO Rollout 5: Estimate advantages Â(a t 6: end for 7:</td></tr></table>

Gather AlgorithmCosine Sim. max z =z kp π θ l (a t |s t , z ) π θ l (a t |s t , z kp )

Table content: <table><tr><td>Snake</td><td>HiPPO on given skills HiPPO on random skills 0.97 ± 0.03 0.98 ± 0.01</td><td>0.09 ± 0.04 0.12 ± 0.03</td><td>0.44 ± 0.03 0.32 ± 0.04</td></tr><tr><td>Ant</td><td>HiPPO on given skills HiPPO on random skills 0.94 ± 0.03 0.96 ± 0.04</td><td>0.11 ± 0.05 0.13 ± 0.05</td><td>0.40 ± 0.08 0.31 ± 0.09</td></tr><tr><td>Table</td><td/><td/><td/></tr></table>

k+1)p-1 t=kp π θ l (a t |s t , z j ) = ∇ θ π θ h (z j |s kp ) (z j |s kp ) ∇ θ π θ l (a t |s t , z j )Thus, we can across the board replace the summation over latents by the single term corresponding to the latent that was sampled at that time. θ l (a t |s t , z kp ) ∇ θ P (z kp |s kp ) log π θ h (z kp |s kp ) + log π θ l (a t |s t , z kp ) + O(nH p-1 )

Table content: <table><tr><td/><td/><td/><td/><td colspan="2">(k+1)p-1</td><td/></tr><tr><td/><td/><td/><td/><td colspan="2">t=kp</td><td/></tr><tr><td/><td/><td/><td/><td colspan="2">t =t</td><td/></tr><tr><td>H/p k=0</td><td colspan="2">π θ h (z kp |s kp )</td><td>1 (k+1)p-1 t=kp</td><td>(k+1)p-1 t=kp</td><td>π θ l (a t |s t , z kp ) +</td><td>nH p</td><td>O(p p-1 )</td></tr><tr><td>H/p</td><td/><td/><td/><td/><td/><td/></tr><tr><td colspan="2">= ∇ = E τ k=0 H/p</td><td colspan="2">∇ H</td><td>∇</td><td/><td/></tr><tr><td/><td>k=0</td><td/><td>t=1</td><td/><td/><td/></tr></table>

log π θ h (z kp |s kp )b(s kp )] = H/p k=0 (s kp ,z kp )P (s kp , z kp )∇ θ log π θ h (z kp |s kp )b(s kp )dz kp ds kp kp π θ h (z kp |s kp )∇ θ log π θ h (z kp |s kp )dz kp ds kp kp π θ h (z kp |s kp ) 1 π θ h (z kp |s kp ) ∇ θ π θ h (z kp |s kp )dz kp ds kpSubtracting a state-and subpolicy-dependent baseline from the second term is also unbiased, i.e.We'll follow the same strategy to prove the second equality: apply the tower property, express the expectation as an integral, and undo the gradient-log trick. log π θ l (a t |s t , z kp )b(s t , z kp )] st,at,z kp [E τ \st,at,z kp [∇ θ log π θm (a t |s t , z kp )b(s t , z kp )]] st,at,z kp [∇ θ log π θ l (a t |s t , z kp )b(s kp , z kp )] (a t |s t , z kp )∇ θ log π θ l (a t |s t , z kp )da t dz kp ds t

Table content: <table><tr><td>H/p</td><td/><td/></tr><tr><td>k=0</td><td>∇ =</td><td>H/p</td></tr><tr><td/><td/><td>k=0 s kp</td></tr><tr><td/><td/><td>H/p</td></tr><tr><td/><td>=</td><td/></tr><tr><td/><td/><td>k=0 s kp</td></tr><tr><td/><td/><td>H/p</td></tr><tr><td/><td>=</td><td/></tr><tr><td/><td/><td>k=0 s kp</td></tr><tr><td/><td/><td>H/p</td></tr><tr><td/><td/><td>k=0 s kp</td></tr><tr><td/><td>E τ [</td><td/></tr><tr><td>E τ [</td><td/><td/></tr><tr><td/><td>H</td><td/></tr><tr><td/><td>= E = t=0 H t=0 E = H</td><td/></tr><tr><td/><td>t=0 (st,z kp )</td><td/></tr></table>

Peer review (iclr2020):
The main problem they try to tackle is to train agents for unseen tasks and environmental changes. They show that their method has a better performance and is more robust against sensor errors and physical parameter alterations. The authors clearly position their work in the HRL paradigm and explain current limitations/challenges within that field. Alike other HRL agents, their method has two types of policies (manager and subpolicies), but different from other works they do not keep parameters fixed in post training for new tasks. In addition to the parameters, they do not fix the time length. The paper is very well written, clearly stated the contributions. Remarks: - Fig 2 has no caption. How are the colors of balls obtained, since they only explain how the sensors (lidar) measure distances to balls (bombs/apples). - Fig 4/5a, some agents (blue) seems to have undesired behaviour (until half of the iterations). This behaviour is not described anywhere. - The URL of the website with code and videos does not have any code. Questions to the authors: - Closest work is Frans et al. (2018). The experiments do not show Frans et al. as a benchmark method. Why? - HiPPO shows to have a higher robustness. Why are the results of different methods (p=10/random) in Table 1 for different environments (Snake/Ant) different?