Data-Efficient Hierarchical Reinforcement Learning
文章来自Google Brain,提出了一种将 off-policy 算法应用在 HRL 框架上的方法 — HIRO (HIerarchical Reinforcement learning with Off-policy correction)。由于 off-policy 的引入,使得数据可以重复利用,所以叫 “data-efficient”。
![](https://i-blog.csdnimg.cn/blog_migrate/edf619aabb1cb7de373ee9225b8aa628.png)
Contribution:
1)成功地将 off-policy 应用在 HRL 的 high-level policy 中。
2)提出了一种 off-policy correction 方法,用于解决 off-policy 在HRL中出现的不稳定问题。
3)由于 off-policy 的引入,提高了 HRL 的数据利用率。
Code: https://github.com/tensorflow/models/tree/master/research/efficient-hrl
直接来看文章的框架:
![](https://i-blog.csdnimg.cn/blog_migrate/055d9438af48c6fad1e7448ee6424fa2.png)
由于是 HRL,所以有两个策略,一个是 high-level policy μ h i \mu^{hi} μhi,另一个是 low-level policy μ l o \mu^{lo} μlo。
-
Env 给出一个初始状态 s 0 s_{_0} s0,传递到 μ h i \mu^{hi} μhi 和 μ l o \mu^{lo} μlo ;
-
然后 μ h i \mu^{hi} μhi 执行动作,即生成一个任务目标 g 0 g_{_0} g0 并传达给 μ l o \mu^{lo} μlo ;
-
μ l o \mu^{lo} μlo 将 s 0 s_{_0} s0 和 g 0 g_{_0} g0 作为输入,并输出动作 a 0 a_{_0} a0,直接作用于Env ;
-
这时候 Env 给出奖励 R 0 R_{_0} R0 ,然后跳到下一个状态 s 1 s_{_1} s1,并将其传递给任务目标转移函数 h h h 和 μ l o \mu^{lo} μlo ;
-
然后用 h h h 代替 μ h i \mu^{hi} μhi,将 g 0 g_{_0} g0 和 s 1 s_{_1} s1 作为输入,生成下一个任务目标 g 1 g_{_1} g1 并传达给 μ l o \mu^{lo} μlo ;
-
μ l o \mu^{lo} μlo 将 s 1 s_{_1} s1 和 g 1 g_{_1} g1 作为输入,并输出动作 a 1 a_{_1} a1,直接作用于Env ;
-
重复 c 次以上动作;
-
因此,每隔 c 个 step, μ h i \mu^{hi} μhi 才执行一次动作。
关于 low-level policy μ l o \mu^{lo} μlo 的训练:
对于 μ l o \mu^{lo} μlo , 文章用了DDPG算法,其经验元组为 ( s t , g t , a t , r t , s t + 1 , g t + 1 ) (s_{_t}, g_{_t}, a_{_t}, r_{_t}, s_{_{t+1}}, g_{_{t+1}}) (st,gt,at,rt,st+1,gt+1)。
DDPG原本要减小的贝尔曼error公式为:
![](https://i-blog.csdnimg.cn/blog_migrate/8133d69a4e488157d01516bdfc376b9a.png)
由于 μ l o \mu^{lo} μlo 还要接收来自 μ h i \mu^{hi} μhi 输出的 g g g,则该公式修改为:
![](https://i-blog.csdnimg.cn/blog_migrate/06c867c4b1ac5b50c30bff5d55b96160.png)
再谈一下在 c steps 之中,生成任务目标 g g g 的目标转移函数 h h h 以及奖励函数 r r r:
![](https://i-blog.csdnimg.cn/blog_migrate/8be4784431b2d81a69f991e019076f3e.png)
![](https://i-blog.csdnimg.cn/blog_migrate/b132a094aeadf618ea7a73271de15950.png)
这两个函数的设计,使得 μ l o \mu^{lo} μlo 的优化目标变为,在任意一个 c steps 内,使机器人的行为匹配 μ h i \mu^{hi} μhi 输出的目标 g g g 。怎么做到的呢?
首先, μ l o \mu^{lo} μlo 要最大化上面的奖励函数,即想要使 s t + g t s_{_t} + g_{_t} st+gt 与 s t + 1 s_{_{t+1}} st+1 之间的差异越来越小。
而 s t s_{_t} st 和 g t g_{_t} gt 是 μ l o \mu^{lo} μlo 在 t t t 时刻已经观察到的观察值,是无法更改的。所以, μ l o \mu^{lo} μlo 只能通过执行动作 a a a,去影响 s t + 1 s_{_{t+1}} st+1 的值,并使其尽量与 s t + g t s_{_t} + g_{_t} st+gt 接近。 实际上,由于目标转移函数 h h h 的设计, s t + g t s_{_t} + g_{_t} st+gt 是一个定值,其大小等于 s 0 + g 0 s_{_0} + g_{_0} s0+g0。
也就是说 μ l o \mu^{lo} μlo 在努力地迫使 Env 出现的下一个状态 s t + 1 = s 0 + g 0 s_{_{t+1}} = s_{_0} + g_{_0} st+1=s0+g0 。
举个简单的例子,一开始 Env 给出了初始状态(1-D) s 0 = 10 s_{_0} =10 s0=10,高级策略 μ h i \mu^{hi} μhi 收到后,给出目标 g 0 = 5 g_{_0} = 5 g0=5,言外之意就是希望经过 c 个 step 后(假设为6),Env 的输出 s c − 1 = 15 s_{_{c-1}} =15 sc−1=15。
μ
l
o
\mu^{lo}
μlo 收到
(
s
0
,
g
0
)
=
(
10
,
5
)
(s_{_0},g_{_0}) = (10,5)
(s0,g0)=(10,5),执行
a
0
a_{_0}
a0,得到
s
1
=
8
s_{_{1}} =\ \ 8
s1= 8,根据
h
h
h,有
g
1
=
s
0
+
g
0
−
s
1
=
7
g_{_1} = s_{_0} + g_{_0} - s_{_1} = 7
g1=s0+g0−s1=7
μ
l
o
\mu^{lo}
μlo 收到
(
s
1
,
g
1
)
=
(
8
,
7
)
(s_{_1},g_{_1}) = (\ \ 8,7)
(s1,g1)=( 8,7),执行
a
1
a_{_1}
a1,得到
s
2
=
9
s_{_{2}} =\ \ 9
s2= 9,根据
h
h
h,有
g
2
=
s
1
+
g
1
−
s
2
=
6
g_{_2} = s_{_1} + g_{_1} - s_{_2} = 6
g2=s1+g1−s2=6
μ
l
o
\mu^{lo}
μlo 收到
(
s
2
,
g
2
)
=
(
9
,
6
)
(s_{_2},g_{_2}) = (\ \ 9,6)
(s2,g2)=( 9,6),执行
a
2
a_{_2}
a2,得到
s
3
=
7
s_{_{3}} =\ \ 7
s3= 7,根据
h
h
h,有
g
3
=
s
2
+
g
2
−
s
3
=
8
g_{_3} = s_{_2} + g_{_2} - s_{_3} = 8
g3=s2+g2−s3=8
μ
l
o
\mu^{lo}
μlo 收到
(
s
3
,
g
3
)
=
(
7
,
8
)
(s_{_3},g_{_3}) = (\ \ 7,8)
(s3,g3)=( 7,8),执行
a
3
a_{_3}
a3,得到
s
4
=
11
s_{_{4}} =11
s4=11,根据
h
h
h,有
g
4
=
s
3
+
g
3
−
s
4
=
4
g_{_4} = s_{_3} + g_{_3} - s_{_4} = 4
g4=s3+g3−s4=4
μ
l
o
\mu^{lo}
μlo 收到
(
s
4
,
g
4
)
=
(
11
,
4
)
(s_{_4},g_{_4}) = (11,4)
(s4,g4)=(11,4),执行
a
4
a_{_4}
a4,得到
s
5
=
10
s_{_{5}} =10
s5=10,根据
h
h
h,有
g
5
=
s
4
+
g
4
−
s
5
=
5
g_{_5} = s_{_4} + g_{_4} - s_{_5} = 5
g5=s4+g4−s5=5
μ
l
o
\mu^{lo}
μlo 收到
(
s
5
,
g
5
)
=
(
10
,
5
)
(s_{_5},g_{_5}) = (10,5)
(s5,g5)=(10,5),执行
a
5
a_{_5}
a5,得到
s
6
=
14
s_{_{6}} =14
s6=14,根据
h
h
h,有
g
6
=
s
6
+
g
5
−
s
6
=
1
g_{_6} = s_{_6} + g_{_5} - s_{_6} = 1
g6=s6+g5−s6=1
可以观察到:
- 得益于 h h h 目标转移函数, s t + g t = s 0 + g 0 = 15 s_{_t} + g_{_t} = s_{_0} + g_{_0}=15 st+gt=s0+g0=15 是固定的。
- 序列 s 0 , s 1 , s 2 , s 3 , s 4 , s 5 , s 6 = 10 , 8 , 9 , 7 , 11 , 10 , 14 s_{_0},s_{_1},s_{_2},s_{_3},s_{_4},s_{_5},s_{_6} = 10,8,9,7,11,10,14 s0,s1,s2,s3,s4,s5,s6=10,8,9,7,11,10,14 虽然上上下下,但一定是不断逼近15的。否则只能说明优化算法 μ l o \mu^{lo} μlo 有误,无法最大化奖励。
关于 high-level policy μ h i \mu^{hi} μhi 的训练:
若 μ l o \mu^{lo} μlo 已能够很好地完成 μ h i \mu^{hi} μhi 给的任务目标,那么 μ h i \mu^{hi} μhi 又是怎么下达目标 g g g 的呢?
划重点,文章的贡献点主要就在这里了。在之前HRL的框架中,high-level policy 只能用 on-policy,若使用 off-policy 则会引起该策略的不稳定。
这个不稳定问题是由 off-policy 对历史经验数据的重复使用造成的,先来看 μ h i \mu^{hi} μhi 的经验元组, ( s t , g t , ∑ R t : t + c − 1 , s t + c ) (s_{_t},g_{_t},\sum R_{_{t:t+c-1}},s_{_{t+c}}) (st,gt,∑Rt:t+c−1,st+c) ,这里的奖励是 c steps 内所有的奖励之和。
- 在确定性环境中,如果一个 Agent 在某个状态 s t s_{_t} st 下,采取动作 a t a_{_t} at,得到奖励 r t r_{_{t}} rt,下一个状态变为 s t + 1 s_{_{t+1}} st+1。那么无论什么时候,只要在那个状态 s t s_{_t} st 下, Agent 采取同样的动作 a t a_{_t} at,得到奖励依旧是 r t r_{_{t}} rt,下一个状态依旧是变为 s t + 1 s_{_{t+1}} st+1,这是固定的。
- 在随机性环境中,如果一个 Agent 在某个状态 s t s_{_t} st 下,采取动作 a t a_{_t} at,得到奖励 r t r_{_{t}} rt,下一个状态变为 s t + 1 s_{_{t+1}} st+1。那么下次在同样的那个状态 s t s_{_t} st 下, Agent 采取同样的动作 a t a_{_t} at,得到的奖励以及下一个状态可能会不同,即以一定的概率跳到 r t ′ r'_{_{t}} rt′ 和 s t + 1 ′ s'_{_{t+1}} st+1′,尽管会跳动,但是它的跳动概率是固定的。所以尽管随机性环境更难学习,但是环境状态转移还是有规律性的。
站在 μ h i \mu^{hi} μhi 的角度,在状态 s t s_{_t} st 下,采取动作 g t g_{_t} gt,得到的奖励是 ∑ R t : t + c − 1 \sum R_{_{t:t+c-1}} ∑Rt:t+c−1,下一个状态是 s t + c s_{_{t+c}} st+c。 这里的下一个状态 s t + c s_{_{t+c}} st+c 是经过 μ l o \mu^{lo} μlo 与环境互动 c steps 后得到的,所以它与 μ l o \mu^{lo} μlo 输出的动作 a a a 有关。所以,对于 μ h i \mu^{hi} μhi 来说, μ l o \mu^{lo} μlo 也算是环境的一部分,因为它会影响 μ h i \mu^{hi} μhi 的下一个状态是 s t + c s_{_{t+c}} st+c。
然而, μ l o \mu^{lo} μlo 是不断在更新的,所以,在同样的状态 s t s_{_t} st 下, μ h i \mu^{hi} μhi 采取同样的动作 g t g_{_t} gt,得到的奖励 ∑ R t : t + c − 1 \sum R_{_{t:t+c-1}} ∑Rt:t+c−1 以及下一个状态 s t + c s_{_{t+c}} st+c 是不断在变化的,而且是没有规律的,完全是随机的 (注,就算是随机性环境,至少还会根据一定的概率进行状态转移)。
这时候, μ h i \mu^{hi} μhi 就会一脸懵逼,根据之前观察到的经验元组 ( s t , g t , ∑ R t : t + c − 1 , s t + c ) (s_{_t},g_{_t},\sum R_{_{t:t+c-1}},s_{_{t+c}}) (st,gt,∑Rt:t+c−1,st+c) 根本就学不到任何东西。 因为经验元组可以变成这样 ( s t , g t , ∑ R t : t + c − 1 ′ , s t + c ′ ) (s_{_t},g_{_t},\sum R'_{_{t:t+c-1}},s'_{_{t+c}}) (st,gt,∑Rt:t+c−1′,st+c′) 或者这样 ( s t , g t , ∑ R t : t + c − 1 ′ ′ , s t + c ′ ′ ) (s_{_t},g_{_t},\sum R''_{_{t:t+c-1}},s''_{_{t+c}}) (st,gt,∑Rt:t+c−1′′,st+c′′) 又或者是这样 ( s t , g t , ∑ R t : t + c − 1 ′ ′ ′ , s t + c ′ ′ ′ ) (s_{_t},g_{_t},\sum R'''_{_{t:t+c-1}},s'''_{_{t+c}}) (st,gt,∑Rt:t+c−1′′′,st+c′′′) ,总之,就是没有规律的元组,同一个状态下执行同一个动作,下一步什么情况都可能会发生。
off-policy correction 闪亮登场:
既然
μ
h
i
\mu^{hi}
μhi 在
s
t
s_{_t}
st 下采取动作
g
t
g_{_t}
gt,由于
μ
l
o
\mu^{lo}
μlo 的不断更新,下一个状态不再转移为
s
t
+
c
s_{_{t+c}}
st+c,变得无规律性。
那么如果这个时候 μ h i \mu^{hi} μhi 采取是另一个动作 g ~ t \tilde{g}_{_t} g~t,这个 g ~ t \tilde{g}_{_t} g~t 使得当前最新的 μ l o \mu^{lo} μlo 策略采取和之前未更新时相同的动作 a a a,那么在 c steps 中,low-level policy μ l o \mu^{lo} μlo 与 Env 的互动关系保持不变,如此一来, s t + c s_{_{t+c}} st+c 也就不会改变了。
举个例子,这里依旧使用上一小节 “关于 low-level policy
μ
l
o
\mu^{lo}
μlo 的训练” 中的数据:
比如在 low-level policy 更新之前:
μ
o
l
d
l
o
\mu^{lo}_{old}
μoldlo 收到
(
s
0
,
g
0
)
=
(
10
,
5
)
(s_{_0},g_{_0}) = (10,5)
(s0,g0)=(10,5),执行
a
0
a_{_0}
a0,得到
s
1
=
8
s_{_{1}} =\ \ 8
s1= 8,根据
h
h
h,有
g
1
=
s
0
+
g
0
−
s
1
=
7
g_{_1} = s_{_0} + g_{_0} - s_{_1} = 7
g1=s0+g0−s1=7
当 low-level policy 更新之后,可能就变成了:
μ
n
e
w
l
o
\mu^{lo}_{new}
μnewlo 收到
(
s
0
,
g
0
)
=
(
10
,
5
)
(s_{_0},g_{_0}) = (10,5)
(s0,g0)=(10,5),执行
a
0
′
a'_{_0}
a0′,得到
s
1
′
=
11
s'_{_{1}} =11
s1′=11,根据
h
h
h,有
g
1
′
=
s
0
+
g
0
−
s
1
′
=
4
g'_{_1} = s_{_0} + g_{_0} - s'_{_1} = 4
g1′=s0+g0−s1′=4
这么搞下去,之前的状态序列 s 0 , s 1 , . . . , s 6 s_{_0},s_{_1},...,s_{_6} s0,s1,...,s6 和动作序列 a 0 , a 1 , . . . , a 6 a_{_0},a_{_1},...,a_{_6} a0,a1,...,a6 就全变了。 因此 s c = s 6 s_{_{c}} = s_{_{6}} sc=s6 就不等于原来的14了。
文章的做法是,采用off-policy correction:
更改 low-level policy 的任务目标
g
g
g,使得更新后的策略
μ
n
e
w
l
o
\mu^{lo}_{new}
μnewlo 能够在新的观察
(
s
0
,
g
~
0
)
=
(
10
,
g
~
0
)
(s_{_0}, \tilde {g}_{_0}) = (10, \tilde {g}_{_0})
(s0,g~0)=(10,g~0) 中,尽可能地采取与更新前同样的动作序列
a
0
,
a
1
,
.
.
.
,
a
6
a_{_0},a_{_1},...,a_{_6}
a0,a1,...,a6,然后,用与原来近似的动作序列与 Env 互动,得到的状态序列
s
0
,
s
1
,
.
.
.
,
s
6
s_{_0},s_{_1},...,s_{_6}
s0,s1,...,s6 也基本不变。 因此达到了不改变
s
c
s_{_{c}}
sc 的目的。
当 low-level policy 更新之后,可能就变成了:
μ
n
e
w
l
o
\mu^{lo}_{new}
μnewlo 收到
(
s
0
,
g
~
0
)
=
(
10
,
g
~
0
)
(s_{_0}, \tilde {g}_{_0}) = (10, \tilde {g}_{_0})
(s0,g~0)=(10,g~0) ,执行
a
0
a_{_0}
a0,得到
s
1
=
8
s_{_{1}} =\ \ 8
s1= 8,根据
h
h
h,有
g
1
′
=
s
0
+
g
~
0
−
s
1
g'_{_1} = s_{_0} + \tilde {g}_{_0} - s_{_1}
g1′=s0+g~0−s1
可见,这里用的任务目标转移函数 h h h 计算方式不变。
那么,怎么去寻找这个 g ~ 0 \tilde {g}_{_0} g~0?
以 s t + c − s t s_{_{t+c}} - s_{_{t}} st+c−st 为高斯采样中心,采取8个样本,然后加上这个采样中心 s t + c − s t s_{_{t+c}} - s_{_{t}} st+c−st,以及原来 μ l o \mu^{lo} μlo未更新时的 g t g_{_t} gt,一共10个参考值。
文章选择的 g ~ 0 \tilde {g}_{_0} g~0 要使得 μ n e w l o ( a t : t + c − 1 ∣ s t : t + c − 1 , g ~ t : t + c − 1 ) \mu^{lo}_{new}(a_{_{t:t+c-1}} | s_{_{t:t+c-1}}, \tilde{g}_{_{t:t+c-1}}) μnewlo(at:t+c−1∣st:t+c−1,g~t:t+c−1) 发生的概率最大,所以,将这10个参考值代入下式进行计算:
![](https://i-blog.csdnimg.cn/blog_migrate/f91afccb326eb811081084124bffa6d1.png)
取获得上式值最大的那个参考值作为 g ~ 0 \tilde {g}_{_0} g~0。