为什么要分层（Hierarchical RL）

普通强化学习在长时间跨度、稀疏奖励的任务（如机器人多阶段操作、迷宫导航）中学习困难。分层强化学习（Hierarchical Reinforcement Learning, HRL）的核心思想是：把复杂任务分解为可复用的子策略（sub-policy），高层负责选择子目标，低层负责执行。

常见 HRL 框架对比：

框架 高层决策粒度 典型表示
Options 选择子策略（option）并决定何时终止 (I, π, β) 三元组
HAM 部分可编程的有限状态机 机器状态
MAXQ 任务分解为子任务值函数 层次 MDP
FeUdal 高层输出隐式目标（goal） 状态抽象

Options 框架的三个要素

一个 Option 是一个三元组：

  • 启动集 I（Initiation set）：option 可以开始执行的状态集合。
  • 内部策略 π（Policy）：option 内部的策略。
  • 终止条件 β（Termination condition）：β(s) 表示在状态 s 终止该 option 的概率。

高层策略每 k 步（或按 β）选择一次 option，低层 option 在其内部执行动作，形成时间抽象。

最小实现（PyTorch）

下面是一个双层 Options 的骨架代码，上层为「高层策略」，下层为「option 内部策略」：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
import torch
import torch.nn as nn
import torch.nn.functional as F


class OptionPolicy(nn.Module):
    """单个 option 的内部策略：状态 -> 动作分布"""

    def __init__(self, obs_dim, act_dim, hidden=64):
        super().__init__()
        self.fc = nn.Sequential(
            nn.Linear(obs_dim, hidden),
            nn.ReLU(),
            nn.Linear(hidden, act_dim),
        )

    def forward(self, obs):
        logits = self.fc(obs)
        return F.softmax(logits, dim=-1)  # 离散动作


class HighLevelController(nn.Module):
    """高层策略：状态 -> option 分布，并输出终止概率"""

    def __init__(self, obs_dim, n_options, hidden=64):
        super().__init__()
        self.fc_option = nn.Linear(obs_dim, n_options)
        self.fc_term = nn.Linear(obs_dim, n_options)  # 每个 option 的 β

    def forward(self, obs):
        option_logits = self.fc_option(obs)
        beta = torch.sigmoid(self.fc_term(obs))  # 终止概率 β(s)
        return F.softmax(option_logits, dim=-1), beta


class OptionsAgent:
    """双层策略的简单封装"""

    def __init__(self, obs_dim, act_dim, n_options=4):
        self.controller = HighLevelController(obs_dim, n_options)
        self.options = nn.ModuleList(
            [OptionPolicy(obs_dim, act_dim) for _ in range(n_options)]
        )
        self.current_option = None

    def act(self, obs):
        # 高层：首次或终止时选择新 option
        if self.current_option is None:
            option_probs, beta = self.controller(obs)
            self.current_option = int(option_probs.argmax().item())
            self.beta = beta[self.current_option]

        # 低层：执行当前 option 的内部策略
        action_probs = self.options[self.current_option](obs)
        action = int(action_probs.argmax().item())

        # 按 β 概率终止当前 option
        if torch.rand(1).item() < self.beta.item():
            self.current_option = None

        return action

训练要点

  1. 两套学习目标：高层学习「选择哪个 option + 何时终止」，低层学习「option 内部如何执行」。
  2. 伪奖励（intrinsic reward）：常给低层 option 一个内部奖励，鼓励其到达高层指定的子目标。
  3. 策略梯度 vs 价值方法：Options 可与 PPO / DQN 等任意底层算法结合。

小结

Options 框架为「分层」提供了一套清晰的数学描述。实际工程中，HRL 的关键在于子任务的自动发现与高层目标的表示，这也是后续可以深入的方向（如 FeUdal 的目标空间抽象、基于语言指令的 HRL 等）。

参考

  • Sutton, Precup & Singh. Between MDPs and semi-MDPs: A framework for temporal abstraction in reinforcement learning.
  • Bacon, Harb & Precup. The Option-Critic Architecture.