本篇笔记将会介绍强化学习的基本概念,马尔可夫决策过程MDP,Bellman方程和动态规划求解MDP问题。
基本概念
history and state history 是一系列观察,行动和奖励的集合。state是history的函数,包含当前状态的信息,并用于决定下一时刻的行动。
policy
π
(
a
∣
s
)
{\pi(a|s)}
π ( a ∣ s ) 代表在状态s下采取行动的策略,换言之就是采取行动a的概率。policy可以是deterministic或stochastic的。
reward & return reward是实时获得的,取决于当前的行动或者说是下一步的状态。return是一段时间内reward的总和,
G
t
=
R
t
+
1
+
γ
R
t
+
2
+
.
.
.
=
∑
k
=
0
∞
γ
k
R
t
+
k
+
1
{G_t = R_{t+1} + \gamma R_{t+2} + ... = \sum\limits _{k=0}^{\infty} \gamma^k R_{t+k+1}}
G t = R t + 1 + γ R t + 2 + . . . = k = 0 ∑ ∞ γ k R t + k + 1 。
value function 用于衡量agent在当前状态好坏程度的函数。 对于MDP,某一个状态的价值函数是
v
π
(
s
)
=
E
π
[
G
t
∣
s
t
]
{v_{\pi}(s) = E_{\pi}[G_t|s_t]}
v π ( s ) = E π [ G t ∣ s t ] ,在当前状态某一个行动的价值函数是
q
π
(
s
,
a
)
=
E
π
[
G
t
∣
s
t
,
a
t
]
{q_{\pi}(s,a) = E_{\pi}[G_t|s_t,a_t]}
q π ( s , a ) = E π [ G t ∣ s t , a t ] 。
policy
策略指在某个状态采取行动a的概率,即
π
(
a
∣
s
)
=
P
[
A
t
=
a
∣
S
t
=
s
]
{\pi(a|s) = P[A_t = a| S_t =s]}
π ( a ∣ s ) = P [ A t = a ∣ S t = s ] 。
optimal policy
最优策略指价值函数最大。 对于任意MDP,均存在最优策略。所有最优决策都达到最优值函数和最优行动值函数。
MRP
Markov reward process是一个带奖励的马尔科夫过程,表示为
<
S
,
P
,
R
,
γ
>
{<S, P, R, \gamma>}
< S , P , R , γ > ,其中S是状态,P是状态转移矩阵,R是奖励
R
s
=
E
[
R
t
+
1
∣
S
t
=
s
]
{R_s = E[R_{t+1}|S_t=s]}
R s = E [ R t + 1 ∣ S t = s ] ,
γ
{\gamma}
γ 是折扣率。
γ
{\gamma}
γ 使得一个无限求和的问题转化为了一个有限求和问题:
G
t
=
∑
k
=
0
∞
γ
k
R
t
+
k
+
1
≤
R
m
a
x
1
−
γ
G_t = \sum\limits_{k = 0}^{\infty} \gamma^k R_{t+k+1} \leq \frac{R_{max}}{1-\gamma}
G t = k = 0 ∑ ∞ γ k R t + k + 1 ≤ 1 − γ R m a x 当
γ
{\gamma}
γ 较大时,far-sighted;当
γ
{\gamma}
γ 较大时,myopic。
MDP
MDP是一个智能体通过采取行动,改变自己的状态,与环境交互并获得奖励的循环过程,其策略完全取决于当前状态。MDP可以认为是一个带决策的MRP,表示为
<
S
,
P
,
A
,
R
,
γ
>
{<S, P, A, R, \gamma>}
< S , P , A , R , γ > ,其中A是行动。
基本上所有的RL问题都可以视为MDP。
MDP还有不少变种,比如说POMDP(Partially Observable MDP),例如自动驾驶汽车我们不知道在遇到某种情况,像撞车,对方采取行动的策略,这种有部分信息未知的情况即属于POMDP。
Bellman function
对于MRP,根据定义有
v
(
s
)
=
E
[
G
t
∣
s
t
]
=
E
[
R
t
+
1
+
γ
G
t
+
1
∣
s
t
]
=
E
[
R
t
+
1
+
γ
v
(
s
+
1
)
∣
s
t
]
{v(s) = E[G_t|s_t]= E[R_{t+1}+\gamma G_{t+1}|s_t] = E[R_{t+1}+\gamma v(s+1)|s_t] }
v ( s ) = E [ G t ∣ s t ] = E [ R t + 1 + γ G t + 1 ∣ s t ] = E [ R t + 1 + γ v ( s + 1 ) ∣ s t ]
即
v
(
s
)
=
R
s
+
γ
∑
s
′
P
s
s
′
v
(
s
′
)
{v(s) = R_s + \gamma \sum\limits_{s'} P_{ss'} v(s')}
v ( s ) = R s + γ s ′ ∑ P s s ′ v ( s ′ ) 。 这个就是Bellman方程,改写为矩阵形式:
v
=
R
+
γ
P
v
{v = R + \gamma Pv}
v = R + γ P v
可以看出来这是个线性方程,可以直接求解v:
v
=
(
1
−
γ
P
)
−
1
v
v = (1- \gamma P)^{-1}v
v = ( 1 − γ P ) − 1 v
时间复杂度为
O
(
n
3
)
O(n^3)
O ( n 3 ) ,只适用于状态数较少的情况。对于更复杂的情况,一般用dynamic programming,Monte-Carlo evaluation或Temporal-Difference learning。
对于MDP,Bellman equation为
v
π
(
s
)
=
∑
a
π
(
a
∣
s
)
(
R
s
a
+
γ
∑
s
′
P
s
s
′
a
v
π
(
s
′
)
)
q
π
(
s
,
a
)
=
R
s
a
+
γ
∑
s
′
P
s
s
′
a
∑
a
′
π
(
a
′
∣
s
′
)
q
π
(
s
′
,
a
′
)
v_{\pi}(s) = \sum\limits_{a} \pi(a|s) (R_s^a + \gamma \sum\limits_{s'} P_{ss'}^a v_{\pi}(s')) \\ q_{\pi}(s,a) = R_s^a + \gamma \sum\limits_{s'} P_{ss'}^a \sum\limits_{a'} \pi(a'|s') q_{\pi}(s',a')
v π ( s ) = a ∑ π ( a ∣ s ) ( R s a + γ s ′ ∑ P s s ′ a v π ( s ′ ) ) q π ( s , a ) = R s a + γ s ′ ∑ P s s ′ a a ′ ∑ π ( a ′ ∣ s ′ ) q π ( s ′ , a ′ )
最优方程是
v
∗
(
s
)
=
m
a
x
a
q
∗
(
s
,
a
)
q
∗
(
s
,
a
)
=
R
s
a
+
γ
∑
s
′
P
s
s
′
a
v
∗
(
s
′
)
v_*(s)= max_a \ q_*(s,a) \\ q_*(s,a) = R_s^a + \gamma \sum\limits_{s'} P_{ss'}^a v_*(s')
v ∗ ( s ) = m a x a q ∗ ( s , a ) q ∗ ( s , a ) = R s a + γ s ′ ∑ P s s ′ a v ∗ ( s ′ )
例子: 如果我们考虑一个简单的4x4迷宫,左上和右下为出口,从第一行第二个点开始依次命名为1,2,3一直到14。在没到出口时reward均为-1,agent采取随机策略,即上下左右均为0.25的几率。那么用bellman equation进行求解。 k = 0时,
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0\ 0\ 0\ 0\\ 0\ 0\ 0\ 0\\ 0\ 0\ 0\ 0\\ 0\ 0\ 0\ 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 k = 1时,来看第一行第二个点(即s = 1)的value function如何变化,套用之前的公式: 此时,矩阵的状态价值函数变为:
0
−
1
−
1
−
1
−
1
−
1
−
1
−
1
−
1
−
1
−
1
−
1
−
1
−
1
−
1
0
\ 0\ \ -1\ -1\ -1\\ -1\ \ -1\ -1\ -1\\ -1\ \ -1\ -1\ -1\\ -1\ \ -1\ -1\ \ \ \ 0\ \\
0 − 1 − 1 − 1 − 1 − 1 − 1 − 1 − 1 − 1 − 1 − 1 − 1 − 1 − 1 0 k = 2时,同理可得每个状态的value 此时,矩阵的状态价值函数变为:
0
−
1.75
−
2.0
−
2.0
−
1.75
−
2.0
−
2.0
−
2.0
−
2.0
−
2.0
−
2.0
−
1.75
−
2.0
−
2.0
−
1.75
0
\ \ 0 \ \ -1.75 -2.0 -2.0\\ -1.75 -2.0 \ -2.0 -2.0\\ \ -2.0 \ -2.0 \ -2.0 -1.75\\ -2.0 \ -2.0 \ -1.75 \ \ \ 0\\
0 − 1 . 7 5 − 2 . 0 − 2 . 0 − 1 . 7 5 − 2 . 0 − 2 . 0 − 2 . 0 − 2 . 0 − 2 . 0 − 2 . 0 − 1 . 7 5 − 2 . 0 − 2 . 0 − 1 . 7 5 0
Note:
P
s
s
′
a
{P_{ss′}^a}
P s s ′ a means the probability of transition from state s to state s′ after you take action a. 所以在这种情况下,如果状态1选择action向左,那么agent是以100%几率到达状态0,即
P
10
l
e
f
t
=
1
{P_{10}^{left} = 1}
P 1 0 l e f t = 1 。
动态规划求解MDP
MDP的问题一般可以分为两类,prediction和control。
prediction输入是MDP+policy或MRP,输出是value function;
control输入是MDP,输出是value function和policy。
求解MDP就是求解Bellman最优方程:
v
∗
(
s
)
=
m
a
x
a
q
∗
(
s
,
a
)
q
∗
(
s
,
a
)
=
R
s
a
+
γ
∑
s
′
P
s
s
′
a
v
∗
(
s
′
)
v_*(s)= max_a \ q_*(s,a) \\ q_*(s,a) = R_s^a + \gamma \sum\limits_{s'} P_{ss'}^a v_*(s')
v ∗ ( s ) = m a x a q ∗ ( s , a ) q ∗ ( s , a ) = R s a + γ s ′ ∑ P s s ′ a v ∗ ( s ′ ) 有两种方法,policy iteration和value iteration。
iterative policy evaluation 给定MDP与策略,策略保持不变,输出value function。是对当前策略的评估。 例子: 左边的策略一直是random policy,没有改变。右边可以视为在当前状态价值函数下的best policy。
policy iteration policy evaluation + policy improvement 基于当前policy,用Bellman Equation更新价值状态函数(即前面Bellman中的例子),然后根据更新后的价值状态函数,利用greedy方法更新策略。 但往往policy会比value更先收敛,所以通常会设置一个阈值
ϵ
=
v
k
+
1
−
v
k
{\epsilon = v_{k+1} - v_{k}}
ϵ = v k + 1 − v k 来控制循环次数。
证明policy improvement可以取到更好的value function: 考虑一个deterministic策略,
a
=
π
(
s
)
a = \pi(s)
a = π ( s ) 。 policy improvement取
a
′
=
a
r
g
m
a
x
a
q
π
(
s
,
a
)
a' = argmax_a \ q_\pi(s,a)
a ′ = a r g m a x a q π ( s , a ) 。 则有
q
π
′
(
s
,
a
′
)
=
m
a
x
a
q
π
(
s
,
a
)
≥
q
π
(
s
,
a
)
=
v
π
(
a
)
q_{\pi'}(s,a') = max_a \ q_\pi(s,a) \geq q_\pi(s,a) = v_\pi(a)
q π ′ ( s , a ′ ) = m a x a q π ( s , a ) ≥ q π ( s , a ) = v π ( a )
v
π
(
a
)
≤
q
π
′
(
s
,
a
′
)
=
E
π
′
(
R
t
+
1
+
γ
v
π
′
(
s
t
+
1
)
∣
s
t
=
s
)
v_\pi(a) \leq q_{\pi'}(s,a') = E_{\pi'}(R_{t+1} + \gamma v_{\pi'}(s_{t+1})|s_t = s)
v π ( a ) ≤ q π ′ ( s , a ′ ) = E π ′ ( R t + 1 + γ v π ′ ( s t + 1 ) ∣ s t = s )
≤
E
π
′
(
R
t
+
1
+
γ
q
π
′
(
s
t
+
1
,
a
t
+
1
′
)
∣
s
t
=
s
)
\leq E_{\pi'}(R_{t+1} + \gamma q_{\pi'}(s_{t+1}, a'_{t+1})|s_t = s)
≤ E π ′ ( R t + 1 + γ q π ′ ( s t + 1 , a t + 1 ′ ) ∣ s t = s )
=
E
π
′
(
R
t
+
1
+
γ
R
t
+
2
+
γ
2
v
π
′
(
s
t
+
2
)
∣
s
t
=
s
)
= E_{\pi'}(R_{t+1} + \gamma R_{t+2} + \gamma^2 v_{\pi'}(s_{t+2})|s_t = s)
= E π ′ ( R t + 1 + γ R t + 2 + γ 2 v π ′ ( s t + 2 ) ∣ s t = s )
≤
.
.
.
≤
v
π
′
(
s
)
\leq ... \leq v_{\pi'}(s)
≤ . . . ≤ v π ′ ( s )
证明policy iteration最后收敛: 当improvement停止时,有
q
π
′
(
s
,
a
′
)
=
m
a
x
a
q
π
(
s
,
a
)
=
v
π
(
a
)
q_{\pi'}(s,a') = max_a \ q_\pi(s,a) = v_\pi(a)
q π ′ ( s , a ′ ) = m a x a q π ( s , a ) = v π ( a ) ,这个正好是bellman optimality equation。所以
v
π
(
s
)
v_\pi(s)
v π ( s ) 达到最优,
π
\pi
π 是最优策略。
value iteration 只考虑更新价值状态函数,先不更新策略,每次计算采取每一个行动后的新价值状态函数,取使其最大的行动。
v
k
+
1
(
s
)
=
m
a
x
a
R
s
a
+
γ
∑
s
′
P
s
s
′
v
k
(
s
′
)
{v_{k+1}(s) = max_a \ R_s^a + \gamma \sum\limits_{s'} P_{ss'} v_{k}(s')}
v k + 1 ( s ) = m a x a R s a + γ s ′ ∑ P s s ′ v k ( s ′ ) 当价值状态函数收敛后,再更新策略。 例子: 左上角为出口,目的是找到去出口的最短路径,除了到terminal state外reward均为-1。
小结:
iterative policy evaluation是一个prediction问题,policy iteration和value iteration均是control问题。
policy iteration 就是在iterative policy evaluation基础上加了一个贪心算法来选择策略。
一般来说,值迭代收敛慢,稳定性较差,但计算量小,策略迭代,收敛快,但计算量大。在状态空间较小时,策略迭代较好,反之,值迭代较好。
policy iteration和value iteration哪个好取决于具体情况。
Asynchronous DP
前面policy iteration和value iteration在循环时并不是实时更新的,会用一张新的表格储存update后的值,等整个矩阵计算完毕后再全部更新。这会造成额外的空间需求,因此出现了异步DP。
异步DP每次直接将更新值取代原有值,并在计算其他状态时用此更新值。所以state ordering在异步DP中很重要,决定了收敛的速率。一般来说有两种方法,一是根据agent之前的经验决定,real-time DP,二是根据Bellman error来决定优先级,Prioritized sweeping DP。
需要注意的是异步DP并不能保证比value iteration收敛得更快,取决于具体情况,但至少能节省一定的空间资源。