动态规划（强化学习2）

b. 对于所有状态s，重复步骤a，直到值函数V(s)不再显著变化。
提取最优策略：在值函数收敛后，可以通过以下方法找到最优策略：对于每个状态s，在所有可能的行动a中选择最大化更新后的值函数的行动，即： π*(s) = argmax [ R(s, a) + γ * Σ P(s' | s, a) * V(s') ]

2.2例子

2.2.1环境

考虑以下简化的格子世界，其中包含 4 个状态和 4 个动作：

状态空间 S = {s1, s2, s3, s4} 动作空间 A = {up, down, left, right}

-----------------
| s1 | s2 | s3 |
-----------------
| s4 | |
-----------------

每个格子的即时奖励如下：

R(s1, up, s1) = -1
R(s1, down, s4) = 10
R(s1, left, s1) = -1
R(s1, right, s2) = -1
R(s2, up, s2) = -1
R(s2, down, s2) = -1
R(s2, left, s1) = -1
R(s2, right, s3) = -1
R(s3, up, s3) = -1
R(s3, down, s3) = -1
R(s3, left, s2) = -1
R(s3, right, s3) = -1
R(s4, up, s1) = -1
R(s4, down, s4) = -1
R(s4, left, s4) = -1
R(s4, right, s4) = -1

折扣因子 γ 设置为 0.9。

初始化初始化值函数 V(s) 为 0，对于所有状态 s ∈ S。

Iteration 1:

V(s1) = 0, V(s2) = 0, V(s3) = 0, V(s4) = 0

Q(s1, up) = -1 + 0.9 * V(s1) = -1 + 0.9 * 0 = -1
Q(s1, down) = 10 + 0.9 * V(s4) = 10 + 0.9 * 0 = 10
Q(s1, left) = -1 + 0.9 * V(s1) = -1 + 0.9 * 0 = -1
Q(s1, right) = -1 + 0.9 * V(s2) = -1 + 0.9 * 0 = -1

Q(s2, up) = -1 + 0.9 * V(s2) = -1 + 0.9 * 0 = -1
Q(s2, down) = -1 + 0.9 * V(s2) = -1 + 0.9 * 0 = -1
Q(s2, left) = -1 + 0.9 * V(s1) = -1 + 0.9 * 0 = -1
Q(s2, right) = -1 + 0.9 * V(s3) = -1 + 0.9 * 0 = -1

Q(s3, up) = -1 + 0.9 * V(s3) = -1 + 0.9 * 0 = -1
Q(s3, down) = -1 + 0.9 * V(s3) = -1 + 0.9 * 0 = -1
Q(s3, left) = -1 + 0.9 * V(s2) = -1 + 0.9 * 0 = -1
Q(s3, right) = -1 + 0.9 * V(s3) = -1 + 0.9 * 0 = -1

Q(s4, up) = -1 + 0.9 * V(s1) = -1 + 0.9 * 0 = -1
Q(s4, down) = -1 + 0.9 * V(s4) = -1 + 0.9 * 0 = -1
Q(s4, left) = -1 + 0.9 * V(s4) = -1 + 0.9 * 0 = -1
Q(s4, right) = -1 + 0.9 * V(s4) = -1 + 0.9 * 0 = -1

更新值函数 V(s)：取q（s,a）中最大

V(s1) = max(-1, 10, -1, -1) = 10
V(s2) = max(-1, -1, -1, -1) = -1
V(s3) = max(-1, -1, -1, -1) = -1
V(s4) = max(-1, -1, -1, -1) = -1

Iteration 2:

Q(s1, up) = -1 + 0.9 * V(s1) = -1 + 0.9 * 10 = 8.9
Q(s1, down) = 10 + 0.9 * V(s4) = 10 + 0.9 * (-1) = 9.1
Q(s1, left) = -1 + 0.9 * V(s1) = -1 + 0.9 * 10 = 8.9
Q(s1, right) = -1 + 0.9 * V(s2) = -1 + 0.9 * (-1) = -2

Q(s2, up) = -1 + 0.9 * V(s2) = -1 + 0.9 * (-1) = -1.9
Q(s2, down) = -1 + 0.9 * V(s2) = -1 + 0.9 * (-1) = -1.9
Q(s2, left) = -1 + 0.9 * V(s1) = -1 + 0.9 * 10 = 8.9
Q(s2, right) = -1 + 0.9 * V(s3) = -1 + 0.9 * (-1) = -2

Q(s3, up) = -1 + 0.9 * V(s3) = -1 + 0.9 * (-1) = -1.9
Q(s3, down) = -1 + 0.9 * V(s3) = -1 + 0.9 * (-1) = -1.9
Q(s3, left) = -1 + 0.9 * V(s2) = -1 + 0.9 * (-1) = -2
Q(s3, right) = -1 + 0.9 * V(s3) = -1 + 0.9 * (-1) = -1.9

Q(s4, up) = -1 + 0.9 * V(s1) = -1 + 0.9 * 10 = 8.9
Q(s4, down) = -1 + 0.9 * V(s4) = -1 + 0.9 * (-1) = -2
Q(s4, left) = -1 + 0.9 * V(s4) = -1 + 0.9 * (-1) = -2
Q(s4, right) = -1 + 0.9 * V(s4) = -1 + 0.9 * (-1) = -2
更新值函数 V(s)：

V(s1) = max(8.9, 9.1, 8.9, -2) = 9.1
V(s2) = max(-1.9, -1.9, 8.9, -2) = 8.9
V(s3) = max(-1.9, -1.9, -2, -1.9) = -1.9
V(s4) = max(8.9, -2, -2, -2) = 8.9

Iteration 3:

Q(s1, up) = -1 + 0.9 * V(s1) = -1 + 0.9 * 9.1 = 8.19
Q(s1, down) = 10 + 0.9 * V(s4) = 10 + 0.9 * 8.9 = 18.01
Q(s1, left) = -1 + 0.9 * V(s1) = -1 + 0.9 * 9.1 = 8.19
Q(s1, right) = -1 + 0.9 * V(s2) = -1 + 0.9 * 8.9 = 7.01

Q(s2, up) = -1 + 0.9 * V(s2) = -1 + 0.9 * 8.9 = 7.01
Q(s2, down) = -1 + 0.9 * V(s2) = -1 + 0.9 * 8.9 = 7.01
Q(s2, left) = -1 + 0.9 * V(s1) = -1 + 0.9 * 9.1 = 8.19
Q(s2, right) = -1 + 0.9 * V(s3) = -1 + 0.9 * (-1.9) = -2.71

Q(s3, up) = -1 + 0.9 * V(s3) = -1 + 0.9 * (-1.9) = -2.71
Q(s3, down) = -1 + 0.9 * V(s3) = -1 + 0.9 * (-1.9) = -2.71
Q(s3, left) = -1 + 0.9 * V(s2) = -1 + 0.9 * 8.9 = 7.01
Q(s3, right) = -1 + 0.9 * V(s3) = -1 + 0.9 * (-1.9) = -2.71

Q(s4, up) = -1 + 0.9 * V(s1) = -1 + 0.9 * 9.1 = 8.19
Q(s4, down) = -1 + 0.9 * V(s4) = -1 + 0.9 * 8.9 = 7.01
Q(s4, left) = -1 + 0.9 * V(s4) = -1 + 0.9 * 8.9 = 7.01
Q(s4, right) = -1 + 0.9 * V(s4) = -1 + 0.9 * 8.9 = 7.01

更新值函数 V(s)：

V(s1) = max(8.19, 18.01, 8.19, 7.01) = 18.01
V(s2) = max(7.01, 7.01, 8.19, -2.71) = 8.19
V(s3) = max(-2.71, -2.71, 7.01, -2.71) = 7.01
V(s4) = max(8.19, 7.01, 7.01, 7.01) = 8.19

2.2.2直到值函数收敛

值迭代算法会持续更新值函数，并在经过足够次数的迭代后，使值函数收敛到最优值函数。此时，我们可以根据最优值函数来确定最优策略。最优策略是选择使得 Q(s, a) 最大的动作 a。在这个例子中，我们不再继续迭代，并假设经过若干次迭代后，值函数已经收敛到最优值函数：

V*(s1) = 17.37
V*(s2) = 16.21
V*(s3) = 7.37
V*(s4) = 16.21

2.2.3得到最优策略 π*

π*(s1) = down
π*(s2) = up
π*(s3) = up
π*(s4) = up

2.3缺点

值迭代是一种保证收敛到最优解的方法，但在大型状态空间上可能需要较多的迭代次数和计算资源。然而，一旦值函数收敛，它提供了MDP的最优策略，使得智能体可以在环境中做出最优决策。

策略迭代（Policy Iteration）：通过交替进行策略评估和改进来找到最优策略。
Q-learning：基于状态-动作对的价值函数，通过更新Q值逼近最优策略。
SARSA：类似于Q-learning，但采用状态-动作-奖励-状态-动作（State-Action-Reward-State-Action）序列进行更新。

虽然DP是一种有效的方法，但它在大型状态空间上的计算复杂性可能会非常高。因此，在实际应用中，可能需要采用其他近似方法，如函数逼近和深度强化学习等。

3.策略迭代

策略迭代是一种经典的求解最优策略的方法。通过交替进行策略评估和策略改进来逐步改进策略，直至找到最优策略。

过程如下：

3.1策略评估（Policy Evaluation）

在策略评估阶段，根据当前的策略估计每个状态的值函数。值函数表示在当前策略下从每个状态开始，预期未来能够获得的累积奖励。策略评估使用 Bellman 方程来递归地更新每个状态的值函数，直到收敛为止。

V(s) = Σ[π(s, a) * Σ[P(s'|s, a) * (R(s, a, s') + γ * V(s'))]], 对所有状态 s ∈ S

需要反复更新值函数 V(s) 直到收敛。一种常用的更新方法是迭代式策略评估，其中在每次更新中，将新的值函数 V(s) 直接用于计算其他状态的值函数，直到所有状态的值函数都不再发生显著变化

3.2策略改进（Policy Improvement）

选择在每个状态下具有最大值函数的动作，更新策略，使得新的策略相对于旧策略更好。这样的更新策略的过程被称为“贪心”策略改进。

if a = argmax[Σ[P(s'|s, a) * (R(s, a, s') + γ * V(s'))]]，对所有动作 a ∈ A, π(s, a) = 1
else π(s, a) = 0

其中，argmax 表示选择使得括号中的值最大的动作 a。

我们更新策略 π(s, a) 后，可能会再次进行策略评估来估计新的值函数 V(s)，然后再进行策略改进。这两个步骤会交替进行直到策略收敛到最优策略为止。

3.3终止条件检查

重复进行策略评估和策略改进，直到策略不再发生改变，即达到最优策略或收敛到局部最优。

3.4例子

环境

同上：状态空间 S = {s1, s2, s3, s4} 动作空间 A = {up, down, left, right}

-----------------
| s1 | s2 | s3 |
-----------------
| s4 | |
-----------------

每个格子的即时奖励如下：

R(s1, up, s1) = -1
R(s1, down, s4) = 10
R(s1, left, s1) = -1
R(s1, right, s2) = -1
R(s2, up, s2) = -1
R(s2, down, s2) = -1
R(s2, left, s1) = -1
R(s2, right, s3) = -1
R(s3, up, s3) = -1
R(s3, down, s3) = -1
R(s3, left, s2) = -1
R(s3, right, s3) = -1
R(s4, up, s1) = -1
R(s4, down, s4) = -1
R(s4, left, s4) = -1
R(s4, right, s4) = -1

折扣因子 γ 设置为 0.9。

Step 1: 初始化策略

随机初始化一个策略 π(s, a)

π(s1, up) = 0.25, π(s1, down) = 0.25, π(s1, left) = 0.25, π(s1, right) = 0.25
π(s2, up) = 0.25, π(s2, down) = 0.25, π(s2, left) = 0.25, π(s2, right) = 0.25
π(s3, up) = 0.25, π(s3, down) = 0.25, π(s3, left) = 0.25, π(s3, right) = 0.25
π(s4, up) = 0.25, π(s4, down) = 0.25, π(s4, left) = 0.25, π(s4, right) = 0.25

Step 2: 策略评估

对当前策略进行策略评估，计算每个状态的值函数 V(s)。

策略评估使用迭代式的 Bellman 期望方程来计算值函数 V(s)。

重复以下步骤直到值函数收敛：

Iterations:

计算该状态的值函数 V(s)：

V(s1) = Σ[π(s1, a) * (R(s1, a, s') + γ * V(s'))]

= 0.25 * (R(s1, up, s1) + 0.9 * V(s1)) + 0.25 * (R(s1, down, s4) + 0.9 * V(s4)) +
0.25 * (R(s1, left, s1) + 0.9 * V(s1)) + 0.25 * (R(s1, right, s2) + 0.9 * V(s2))
= 0.25 * (-1 + 0.9 * V(s1)) + 0.25 * (10 + 0.9 * V(s4)) + 0.25 * (-1 + 0.9 * V(s1)) + 0.25 * (-1 + 0.9 * V(s2))

V(s2) = 0.25 * (-1 + 0.9 * V(s2)) + 0.25 * (-1 + 0.9 * V(s2)) + 0.25 * (-1 + 0.9 * V(s1)) + 0.25 * (-1 + 0.9 * V(s3))
V(s3) = 0.25 * (-1 + 0.9 * V(s3)) + 0.25 * (-1 + 0.9 * V(s3)) + 0.25 * (-1 + 0.9 * V(s2)) + 0.25 * (-1 + 0.9 * V(s3))
V(s4) = 0.25 * (-1 + 0.9 * V(s1)) + 0.25 * (-1 + 0.9 * V(s4)) + 0.25 * (-1 + 0.9 * V(s4)) + 0.25 * (-1 + 0.9 * V(s4))

区别-------值迭代的函数：     V(s) ← max [ R(s, a) + γ * Σ P(s' | s, a) * V(s') ]


重复以上步骤直到值函数收敛。假设经过若干次迭代后，值函数已经收敛，最终的值函数 V* 为：
V*(s1) = 18.963
V*(s2) = 17.067
V*(s3) = 17.067
V*(s4) = 18.963

Step 3: 策略改进

对当前的值函数 V* 进行策略改进，更新策略 π(s, a) 使得 Q(s, a) 最大的动作 a。

π(s1, up) = argmax(Q(s1, up)),

π(s1, down) = argmax(Q(s1, down)),

π(s1, left) = argmax(Q(s1, left)),

π(s1, right) = argmax(Q(s1, right))
π(s2, up) = argmax(Q(s2, up)),

π(s2, down) = argmax(Q(s2, down)),

π(s2, left) = argmax(Q(s2, left)),

π(s2, right) = argmax(Q(s2, right))
π(s3, up) = argmax(Q(s3, up)),

π(s3, down) = argmax(Q(s3, down)),

π(s3, left) = argmax(Q(s3, left)),

π(s3, right) = argmax(Q(s3, right))
π(s4, up) = argmax(Q(s4, up)),

π(s4, down) = argmax(Q(s4, down)),

π(s4, left) = argmax(Q(s4, left)),

π(s4, right) = argmax(Q(s4, right))

根据最优策略进行更新后，新的策略为：

π*(s1, up) = 0, π*(s1, down) = 1, π*(s1, left) = 0, π*(s1, right) = 0
π*(s2, up) = 0, π*(s2, down) = 0, π*(s2, left) = 0, π*(s2, right) = 1
π*(s3, up) = 0, π*(s3, down) = 0, π*(s3, left) = 0, π*(s3, right) = 1
π*(s4, up) = 0, π*(s4, down) = 0, π*(s4, left) = 0, π*(s4, right) = 0

直到策略和值函数都收敛到最优。

4策略迭代VS值迭代

值迭代是直接通过逐步迭代计算值函数，然后从值函数中选择最优动作作为策略。策略迭代则在值迭代的基础上，进一步在每次迭代中进行策略的改进。策略迭代的优势在于即使在初始时，策略不是最优的，但随着交替迭代，策略逐渐收敛到最优策略。

1. 策略迭代（Policy Iteration）:策略迭代是一种模型基于的方法，它交替进行策略评估和策略改进来找到最优策略。主要优点是在有限步骤内保证收敛到最优策略。每个策略迭代步骤都会增加策略的质量，直到最优策略被找到。

2. 值迭代（Value Iteration）:https://v5.bootcss.com/docs/getting-started/introduction/值迭代的主要优点是它通常比策略迭代更高效。因为值迭代直接更新值函数，并在一步中同时完成了策略改进的步骤，因此它通常比策略迭代收敛更快。

区别总结：

策略迭代是通过交替进行策略评估和策略改进来找到最优策略，而值迭代是通过直接迭代更新值函数来找到最优值函数和最优策略。
策略迭代保证收敛到最优策略，每个步骤增加策略的质量，而值迭代通过一步更新即可直接收敛到最优值函数和最优策略。
值迭代通常比策略迭代更高效，因为它可以在一步中完成策略改进的过程。但在每个迭代步骤中，值迭代需要遍历所有状态和动作来更新值函数，可能在状态空间较大时计算代价较高。

清风慢行

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
动态规划（强化学习2）

在强化学习中，"DP"是"Dynamic Programming"（动态规划）的缩写。Dynamic Programming（动态规划）是一种用于解决具有重叠子问题性质和问题的算法技术。在强化学习中，DP被用于解决最优控制问题，特别是在有限马尔可夫决策过程（Finite Markov Decision Process，简称MDP）中。动态规划算法通过在MDP中的状态空间上进行迭代，计算每个状态的最优值函数（Value Function）或最优策略（Policy）。
复制链接

扫一扫