1. 什么是策略迭代
从1个初始策略
π
(
a
∣
s
)
\pi(a|s)
π(a∣s)出发,先利用贝尔曼期望方程(
V
′
→
V
V'\to V
V′→V)迭代更新状态值函数
V
π
(
s
)
V_\pi(s)
Vπ(s),进而根据贝尔曼期望方程(
V
→
Q
V\to Q
V→Q)求
Q
π
(
s
,
a
)
Q_\pi(s,a)
Qπ(s,a),最后使用贪心算法,根据
Q
π
(
s
,
a
)
Q_\pi(s,a)
Qπ(s,a)更新
π
(
a
∣
s
)
\pi(a|s)
π(a∣s),如此反复进行,直到策略收敛到满足设定条件为止。
π
1
E
→
V
π
1
,
Q
π
1
I
→
π
2
E
→
V
π
2
,
Q
π
2
I
→
⋯
,
Q
∗
I
→
π
∗
\pi_1\underrightarrow{\quad E\quad}V_{\pi_1},Q_{\pi_1} \underrightarrow{\quad I\quad}\pi_2\underrightarrow{\quad E\quad}V_{\pi_2},Q_{\pi_2}\underrightarrow{I}\cdots,Q^*\underrightarrow{I}\pi^*
π1EVπ1,Qπ1Iπ2EVπ2,Qπ2I⋯,Q∗Iπ∗
2 策略迭代算法流程
2.1 变量说明
输入变量
S
=
[
s
1
,
s
2
,
⋯
,
s
m
]
S=[s_1,s_2,\cdots,s_m]
S=[s1,s2,⋯,sm]:状态空间,共有m种状态
A
=
[
a
1
,
a
2
,
⋯
,
s
n
]
A=[a_1,a_2,\cdots,s_n]
A=[a1,a2,⋯,sn]:动作空间,共有n种动作
P
P
P:三维数组,维度为
(
n
,
m
,
m
)
(n,m,m)
(n,m,m),
P
[
i
,
j
,
k
]
P[i,j,k]
P[i,j,k]表示执行动作
a
i
(
1
≤
i
≤
n
)
a_i(1\le i\le n)
ai(1≤i≤n)时,环境由状态
s
j
(
1
≤
j
≤
m
)
s_j(1\le j\le m)
sj(1≤j≤m)转移到状态
s
k
(
1
≤
k
≤
m
)
s_k(1\le k\le m)
sk(1≤k≤m)的概率
R
R
R:m×n矩阵,
R
[
i
,
j
]
(
1
≤
i
≤
m
,
1
≤
j
≤
n
)
R[i,j](1\le i\le m,1\le j\le n)
R[i,j](1≤i≤m,1≤j≤n)表示在状态
s
i
s_i
si时执行动作
a
j
a_j
aj时获得的立即回报(期望)。
g
a
m
a
gama
gama:折扣因子,
e1:相邻两次迭代的状态值函数之差小于该值,结束值函数迭代
中间变量:
V
−
1
×
m
V-1×m
V−1×m向量,用来存储状态值函数,
V
[
k
]
(
1
≤
k
≤
m
)
V[k](1\le k\le m)
V[k](1≤k≤m)表示状态
s
k
s_k
sk的值函数值
输出变量
P
i
−
策略矩阵,
m
×
n
,
P
i
[
i
,
j
]
表示状态为
s
i
时采取动作
a
j
的概率
Pi-策略矩阵,m×n,Pi[i,j]表示状态为s_i时采取动作a_j的概率
Pi−策略矩阵,m×n,Pi[i,j]表示状态为si时采取动作aj的概率
2.2 算法流程

图中,computeV子函数用于更新状态
s
k
s_k
sk的值函数的值,其计算参照如下公式:
V
k
+
1
(
s
)
=
∑
a
∈
A
π
(
a
∣
s
)
(
R
s
a
+
γ
∑
s
′
∈
S
P
s
s
′
a
V
k
(
s
′
)
)
V_{k+1}(s)=\sum_{a\in A}\pi(a|s)\left(R_s^a+\gamma\sum_{s'\in S}P_{ss'}^aV_k(s')\right)
Vk+1(s)=a∈A∑π(a∣s)(Rsa+γs′∈S∑Pss′aVk(s′))
注意:在实际编程时,应将
V
k
+
1
(
s
)
V_{k+1}(s)
Vk+1(s)先用一个变量
v
n
e
w
v_{new}
vnew存储下来,并计算它与原来s状态下的状态值函数
V
k
(
s
)
V_k(s)
Vk(s)的差的绝对值
β
\beta
β,然后再将向量V中的索引号为s的元素更新为
v
n
e
w
v_{new}
vnew.
此外,每一个状态都有一个
β
\beta
β值,所有状态的
β
\beta
β值存到一个向量中B中,当所有状态都迭代了一次后,就检查B中所有元素是否都小于某个设定好的阈值threshold,若小于,就跳出值函数的迭代循环。使用numpy数组完成这种运算非常简单,代码类似如下:
if (B<threshold).all():
break
computeA子函数用于计算最优动作a^*_k,返回动作对应的序号k
其计算公式如下:
a
∗
=
arg
max
a
∈
A
[
R
s
a
+
γ
∑
s
′
∈
S
P
s
s
′
a
V
(
s
′
)
]
a^*=\arg\max_{a\in A}[R_s^a+\gamma\sum_{s'\in S}P_{ss'}^aV(s')]
a∗=arga∈Amax[Rsa+γs′∈S∑Pss′aV(s′)]
编程注意事项 很可能一个状态下对应1个以上的最优动作,即:使得上式成立的a有1个以上,假设有k个,则策略矩阵中相应状态下,对应的动作的概率都为1/k,其余为0,若只有1个最优动作,则其对应的概率为1,其余为0
649

被折叠的 条评论
为什么被折叠?



