Data-Efficient Hierarchical Reinforcement Learning
文章来自Google Brain,提出了一种将 off-policy 算法应用在 HRL 框架上的方法 — HIRO (HIerarchical Reinforcement learning with Off-policy correction)。由于 off-policy 的引入,使得数据可以重复利用,所以叫 “data-efficient”。
Contribution:
1)成功地将 off-policy 应用在 HRL 的 high-level policy 中。
2)提出了一种 off-policy correction 方法,用于解决 off-policy 在HRL中出现的不稳定问题。
3)由于 off-policy 的引入,提高了 HRL 的数据利用率。
直接来看文章的框架:
由于是 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公式为:
由于 μ l o \mu^{lo} μlo 还要接收来自 μ h i \mu^{hi} μhi 输出的 g g g,则该公式修改为:
再谈一下在 c steps 之中,生成任务目标 g g g 的目标转移函数 h h h 以及奖励函数 r r r:
这两个函数的设计,使得 μ 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
可以观察到:
关于 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 内所有的奖励之和。
站在 μ 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个参考值代入下式进行计算:
取获得上式值最大的那个参考值作为 g ~ 0 \tilde {g}_{_0} g~0。