【RL Latest Tech】分层强化学习（Hierarchical RL）

分层强化学习（Hierarchical Reinforcement Learning，HRL）是一类旨在通过引入多层次结构来提高强化学习算法效率的方法。其核心思想是将复杂的任务分解为若干子任务，通过解决这些子任务来最终完成整体目标。

不去幼儿园

1225人浏览 · 2024-10-01 08:00:00

不去幼儿园 · 2024-10-01 08:00:00 发布

📢本篇文章是博主强化学习RL领域学习时，用于个人学习、研究或者欣赏使用，并基于博主对相关等领域的一些理解而记录的学习摘录和笔记，若有不当和侵权之处，指出后将会立即改正，还望谅解。文章分类在👉强化学习专栏：

【强化学习】（22）---《分层强化学习（Hierarchical RL）》

分层强化学习（Hierarchical RL）

5.3FeUdal Networks（FuN）

[Python] 伪代码

1. Option-Critic 架构

2. MAXQ 分解

3. FeUdal Networks (FuN)

分层强化学习（Hierarchical Reinforcement Learning，HRL）是一类旨在通过引入多层次结构来提高强化学习算法效率的方法。其核心思想是将复杂的任务分解为若干子任务，通过解决这些子任务来最终完成整体目标。以下是关于分层强化学习的详细介绍：

1.HRL背景

强化学习（Reinforcement Learning, RL）是一种让代理通过与环境互动来最大化累计奖励的方法。RL问题通常用马尔可夫决策过程（Markov Decision Process, MDP）来描述，想更为细致的了解强化学习，可以阅读这篇文章【RL】强化学习入门：从基础到应用

尽管RL在许多领域取得了显著成功，但对于复杂、大规模的任务，传统RL方法面临一些挑战：

高维度状态空间：状态空间的维度增加会导致“维数灾难”，使得学习变得极其困难。
长期依赖与稀疏奖励：在一些任务中，奖励信号非常稀疏，且代理需要进行长时程规划才能获取奖励。
探索与利用的权衡：平衡探索新策略和利用已有策略之间的关系在复杂任务中尤为重要。

为了应对这些挑战，分层强化学习（HRL）应运而生。HRL通过引入层次结构，将复杂任务分解为若干子任务，从而降低任务的复杂性并提高学习效率。最早提出分层思想的是Sutton等人在1999年提出的选项框架（Options Framework）。

2.HRL基本思想

HRL的核心思想是将复杂任务分解成更易处理的子任务，各层次间可以分别进行优化和决策。主要方法包括：

选项框架：将高级行为抽象为选项，通过定义初始集、政策和终止条件，简化策略学习。
MAXQ 分解：通过分解价值函数，将复杂任务的值函数表示为若干子任务的值函数之和。
FeUdal Networks：采用管理者-工人架构，高层管理者设定目标，低层工人执行具体操作。

3.HRL基本概念

层次结构：分层强化学习中通常存在多个层次，每个层次负责不同粒度的决策。高层次负责抽象和长期规划，而低层次负责具体操作和短期执行。
选项（Options）框架：这是分层强化学习的一种重要方法，将行动策略视为可选项（option），每个选项由三个部分组成：
- 初始集（Initiation Set）：定义在哪些状态下可以选择该选项。
- 政策（Policy）：定义在选项被激活期间如何进行行动选择。
- 终止条件（Termination Condition）：定义何时结束该选项。
半马尔可夫决策过程（Semi-Markov Decision Process，SMDP）：由于选项可能会持续不定长时间，因此分层强化学习常用SMDP来建模，这种模型允许动作（即选项）具有可变长度的持续时间。

4.HRL优点

减少搜索空间：通过分解任务，高层次的决策能够有效减少低层次需要探索的状态和动作空间，从而加速学习。
提高样本效率：通过共享和重用子任务的经验，可以显著提升样本利用率，减少训练所需的样本数量。
更好的泛化能力：分层结构使得在不同但相关的任务之间迁移学习变得更加容易。

5.HRL主要方法

5.1Option-Critic 架构

这是一种端到端的分层强化学习方法，可以同时学习选项和选项间的政策。它通过梯度下降法优化选项的终止条件和内部策略。

论文标题: The Option-Critic Architecture

作者: Pierre-Luc Bacon, Jean Harb, Doina Precup

内容简介: Option-Critic架构是一种端到端的分层强化学习方法，能够同时学习选项（options）及其相关政策。该方法通过引入梯度下降优化选项的终止条件和内部策略，从而实现高效的分层决策过程。

核心贡献:

选项框架：定义了选项的三个基本组成部分：初始集、政策和终止条件。
选项的学习：提出了一种基于梯度下降的方法来优化选项的终止条件和内部策略。
实验验证：在多种标准测试环境中展示了Option-Critic架构的有效性。

重要公式:

选项值函数 $( Q^{\mu}(s, o) ) [ Q^{\mu}(s, o) = \mathbb{E}\left[ \sum_{t=0}^{T-1} \gamma^t r_t \mid s_0 = s, o \right] ]$ 其中， $(o)$ 是当前选项， $(T)$ 是选项的持续时间。
选项纲领梯度： $[ \nabla_{\theta_u} J(U) = \mathbb{E}\left[ \sum_{t=0}^{T-1} \nabla_{\theta_u} \log \pi_u(a_t \mid s_t; \theta_u) A_u(s_t, a_t) \right] ]$ 其中， $(A_u(s_t, a_t))$ 是优势函数。
终止条件梯度： $[ \nabla_{\beta} J(\beta) = - \mathbb{E}[\nabla_{\beta} \beta(s) (Q_U(s, (I - \beta)(U) - V(s)))] ]$ 其中， $(\beta(s))$ 是终止条件函数。

算法详细介绍：【RL Latest Tech】分层强化学习：Option-Critic架构算法

5.2MAXQ 分解

该算法将价值函数分解为不同层次的子任务，每个子任务都有自己的价值函数，从而简化了复杂任务的求解。

论文标题: Hierarchical Reinforcement Learning with the MAXQ Value Function Decomposition

作者: Thomas G. Dietterich

内容简介: MAXQ分解方法提出了一种将强化学习中的复杂任务分解为多个子任务的方法，这些子任务各自有独立的价值函数。通过这种方式，可以显著减少状态-动作对的组合数量，从而提高学习效率。

核心贡献:

值函数分解：论文提出了将整体任务的值函数分解为若干子任务的值函数的框架。 $( a )$
层次结构：定义了一个层次任务图（Task Graph），描述了主任务和子任务之间的关系。
学习算法：提出了基于MAXQ分解的层次强化学习算法，能够有效地在多层次任务中学习最优策略。
理论证明：提供了数学证明，展示了MAXQ分解方法的正确性和收敛性。
实验验证：通过多个实验，验证了MAXQ分解方法在不同环境中的有效性和优越性。

主要思想:

任务分解：将复杂任务分解为若干子任务，每个子任务可以进一步分解，直到达到原子操作级别。
层次任务图：使用层次任务图表示任务的分解结构，每个节点代表一个子任务，对应的边表示子任务之间的调用关系。
递归学习：使用递归方法在不同层次间进行学习，通过逐层优化子任务来最终优化整体任务。

重要公式: MAXQ值函数分解的核心公式之一是： $[ Q(s, a) = V(s) + C(s, a) ]$

其中：

$( Q(s, a) )$ 是在状态 $( s )$ 下执行动作 $( a )$ 的值函数。
$( V(s) )$ 是状态 $( s )$ 的值函数。分层价值函数： $[ V(s) = \sum_{a \in \text{actions}} \pi(a \mid s) Q(s, a) ]$
$( C(s, a) )$ 是在状态 $( s )$ 下选择动作 $( a )$ 后完成余下任务的成本。

实用性: MAXQ 分解适用于那些天然具有层次结构的任务，比如机器人控制、策略游戏等。这些任务可以被自然地分解为多个子任务，使得MAXQ方法能够充分发挥其优势，提高学习效率和效果。

算法详细介绍：【RL Latest Tech】分层强化学习：MAXQ分解算法

5.3FeUdal Networks（FuN）

这种方法使用管理者-工人（Manager-Worker）架构，在高层次上，管理者通过设定目标指导低层次的工人去实现这些目标。

论文标题: FeUdal Networks for Hierarchical Reinforcement Learning

作者: Marlos C. Machado, Marc G. Bellemare, Michael Bowling

内容简介: FeUdal Networks (FuN) 方法引入了管理者-工人（Manager-Worker）架构。在高层次上，管理者设定目标，指导低层次的工人去实现这些目标。这种方法使得模型能够有效处理长时程依赖问题。

核心贡献:

管理者-工人架构：提出了一种分层结构，其中高层次的管理者设定目标，低层次的工人实施具体操作。
目标设定：管理者通过设定目标，使得工人的行为更有针对性。
实验验证：在多种游戏环境中进行了实证验证，展示了该方法的有效性。

重要公式:

管理者目标函数： $[ g_t = g_{t-1} + c_t ]$ 其中，

$( g_t )$ 是管理者在时间步 $( t )$ 的目标向量
$( c_t )$ 是管理者在时间步 $( t )$ 的子目标变化向量
工人策略： $[ \pi_w(a \mid s, g) = \frac{\exp(Q_w(s, a; g))}{\sum_{a'} \exp(Q_w(s, a'; g))} ]$

算法详细介绍：【RL Latest Tech】分层强化学习：FeUdal Networks算法

[Python] 伪代码

🔥以下是Option-Critic架构、MAXQ分解和FeUdal Networks（FuN）三种算法的Python伪代码。这些伪代码旨在提供一个概念性框架，以帮助理解每种方法的基本操作流程。

1. Option-Critic 架构

Option-Critic的核心在于学习选项的内部策略以及终止条件。下面是该算法的主要步骤伪代码：

"""《Option-Critic架构伪代码》
    时间：2024.09.29
    作者：不去幼儿园
"""
import numpy as np

class OptionCritic:
    def __init__(self, num_states, num_actions, num_options):
        self.num_states = num_states
        self.num_actions = num_actions
        self.num_options = num_options
        
        # 初始化每个选项的策略和终止函数
        self.policies = [np.random.randn(num_states, num_actions) for _ in range(num_options)]
        self.terminations = [np.random.rand(num_states) for _ in range(num_options)]
        self.q_values = np.random.randn(num_states, num_options)
        
    def select_option(self, state):
        # 根据状态选择最优选项
        return np.argmax(self.q_values[state])

    def select_action(self, state, option):
        # 在选项内根据状态选择最优动作
        return np.argmax(self.policies[option][state])
    
    def update_policy(self, state, option, action, reward, next_state):
        # 使用梯度下降更新选项的内部策略
        pass
    
    def update_termination(self, state, option, reward, next_state):
        # 使用梯度下降更新选项的终止条件
        pass
    
    def train(self, env, episodes):
        for episode in range(episodes):
            state = env.reset()
            option = self.select_option(state)
            
            while True:
                action = self.select_action(state, option)
                next_state, reward, done, _ = env.step(action)

                self.update_policy(state, option, action, reward, next_state)
                
                if self.terminations[option][state] > np.random.rand():
                    option = self.select_option(next_state)
                
                if done:
                    break
                
                state = next_state

2. MAXQ 分解

MAXQ分解将任务分解为子任务，每个子任务有独立的值函数。以下是该方法的主要步骤伪代码：

"""《 MAXQ分解 伪代码》
    时间：2024.09.29
    作者：不去幼儿园
"""

class MAXQNode:
    def __init__(self, name, children=None):
        self.name = name
        self.children = children if children else []
        self.value_function = {}

    def get_value(self, state):
        # 获取当前状态下的值函数
        if self.children:
            return max(child.get_value(state) for child in self.children)
        return self.value_function.get(state, 0)

    def set_value(self, state, value):
        # 设置当前状态下的值函数
        self.value_function[state] = value

class MAXQAgent:
    def __init__(self, root_task):
        self.root_task = root_task

    def train(self, env, episodes):
        for episode in range(episodes):
            state = env.reset()
            self._train_recursive(self.root_task, state, env)

    def _train_recursive(self, node, state, env):
        if not node.children:
            # 原子动作节点
            next_state, reward, done, _ = env.step(node.name)
            node.set_value(state, reward + max(child.get_value(next_state) for child in node.children))
            return reward
        
        total_reward = 0
        while True:
            subtask = self._select_subtask(node, state)
            reward = self._train_recursive(subtask, state, env)
            total_reward += reward
            
            if env.is_terminal(state):
                break
                
        node.set_value(state, total_reward)
        return total_reward

    def _select_subtask(self, parent, state):
        # 选择在当前状态下值最大的子任务
        return max(parent.children, key=lambda child: child.get_value(state))

# 创建任务和子任务
primitive_actions = [MAXQNode("move"), MAXQNode("pickup"), MAXQNode("putdown")]
root_task = MAXQNode("root", primitive_actions)

agent = MAXQAgent(root_task)
agent.train(env, episodes=1000)

3. FeUdal Networks (FuN)

FeUdal Networks (FuN)采用管理者-工人架构来处理长时程依赖问题。以下是该方法的主要步骤伪代码：

"""《FeUdal Networks (FuN)伪代码》
    时间：2024.09.29
    作者：不去幼儿园
"""

import numpy as np

class FuNAgent:
    def __init__(self, state_dim, action_dim, goal_dim):
        self.state_dim = state_dim
        self.action_dim = action_dim
        self.goal_dim = goal_dim
        
        # 初始化管理者和工人网络的参数
        self.manager_params = np.random.randn(goal_dim, state_dim)
        self.worker_params = np.random.randn(action_dim, state_dim + goal_dim)
        
    def select_goal(self, state):
        # 管理者根据状态选择目标向量
        return np.dot(self.manager_params, state)
    
    def select_action(self, state, goal):
        # 工人根据状态和目标选择动作
        augmented_state = np.concatenate([state, goal])
        return np.argmax(np.dot(self.worker_params, augmented_state))
    
    def update_manager(self, state, goal, reward, next_state):
        # 更新管理者网络（例如使用策略梯度）
        pass
    
    def update_worker(self, state, goal, action, reward, next_state):
        # 更新工人网络（例如使用Q学习）
        pass
    
    def train(self, env, episodes):
        for episode in range(episodes):
            state = env.reset()
            goal = self.select_goal(state)
            
            while True:
                action = self.select_action(state, goal)
                next_state, reward, done, _ = env.step(action)
                
                self.update_worker(state, goal, action, reward, next_state)
                intrinsic_reward = np.dot(goal, next_state - state)
                self.update_manager(state, goal, intrinsic_reward, next_state)
                
                if done or np.linalg.norm(next_state - state) < threshold:
                    goal = self.select_goal(next_state)
                
                if done:
                    break
                    
                state = next_state