Skip to content

A
apachecn-dl-zh

大唐爆破僧 / apachecn-dl-zh
与 Fork 源项目一致

Fork自 OpenDocCN / apachecn-dl-zh

通知 1
Star 0
Fork 0
A
apachecn-dl-zh

体验新版 GitCode，发现更多精彩内容 >>

提交 0e484ded 编写于 作者: W wizardforcel
浏览文件
操作

2021-01-17 20:42:26

上级 228c2269
隐藏空白更改
内联 并排
Showing with 93 addition and 93 deletion
new/rl-tf/03.md
浏览文件 @ 0e484ded
......@@ -71,7 +71,7 @@ MDP 试图通过将网格划分为状态，动作，模型/转换模型和奖励
这两种情况的行为取决于某些因素：
* **确定的环境**：在确定的环境中，如果您采取某种行动，例如说`UP`，则您肯定会以概率 1 执行该行动。
* **随机环境**：在随机环境中，如果您执行相同的操作（例如说`UP`），则有一定的概率说 0.8 可以实际执行给定的操作，而有 0.1 的概率可以执行 垂直于给定动作`UP`的动作（`LEFT`或`RIGHT`）。 在此，对于 s 状态和`UP`动作转换模型，`T(s', UP, s) = P(s' | s, UP) = 0.8`。
* **随机环境**：在随机环境中，如果您执行相同的操作（例如说`UP`），则有一定的概率说 0.8 可以实际执行给定的操作，而有 0.1 的概率可以执行 垂直于给定动作`UP`动作（`LEFT`或`RIGHT`）。 在此，对于 s 状态和`UP`动作转换模型，`T(s', UP, s) = P(s' | s, UP) = 0.8`。
由于`T(s, a, s') ~ P(s' | s, a)`，因此新状态的概率仅取决于当前状态和操作，而与过去状态无关。 因此，过渡模型遵循一阶马尔可夫性质。
......@@ -195,7 +195,7 @@ MDP 试图通过将网格划分为状态，动作，模型/转换模型和奖励
![](img/c1a7f9d8-d174-4168-b470-01cde9c8ec20.png)
其中， *T（s，a，s'）*是转移概率，即 *P（s'| s，a）*和 *U（s'）[ 在对*的*状态采取*动作后，是新着陆状态的实用程序。
其中，`T(s, a, s')`是转移概率，即`P(s' | s, a)`；在对`s`状态采取`a`动作后，`U(s')`是新着陆状态的效用。
![](img/c7961616-4973-4920-969e-2ac20e4661b1.png)指的是针对特定行动采取的所有可能的新状态结果的总和，然后无论哪个行动给出了![](img/bde26e3c-33c6-446d-90be-164102224f37.png)的最大值，该最大值被认为是最优策略的一部分，因此， 状态由以下 **Bellman 方程**给出，
......@@ -241,7 +241,7 @@ MDP 试图通过将网格划分为状态，动作，模型/转换模型和奖励
* ![](img/c5ef3106-3865-42ac-b31d-00932fc9bdef.png)，![](img/42d4df8a-cfdd-4178-b0f2-bd11a5ae69d4.png)（即，对除`G`和`B`状态之外的所有状态的奖励是-0.04），![](img/b4354f1f-4615-42ee-b355-e822c11f4a12.png)（即，第一个实用程序 除`G`和`B`状态外，时间步长为 0。
* 如果沿期望的方向前进，则过渡概率 *T（s，a，s'）*等于 0.8； 否则，如果垂直于所需方向，则各为 0.1。 例如，如果操作是*升*，则概率为 0.8，代理会*升*，但概率为 0.1 时，它会*右*，而 0.1 则降为 *LEFT* 。
* 如果沿期望的方向前进，则过渡概率`T(s, a, s')`等于 0.8； 否则，如果垂直于所需方向，则各为 0.1。 例如，如果操作是`UP`，则概率为 0.8，代理会`UP`，但概率为 0.1 时，它会`RIGHT`，而 0.1 则为`LEFT`。
问题：
......@@ -254,41 +254,41 @@ MDP 试图通过将网格划分为状态，动作，模型/转换模型和奖励
![](img/827fc525-4ce3-4ba0-8b43-6f8abfbc5592.png)
*R（X）= -0.04*
`R(X) = -0.04`
| **行动** | **s'** | **![](img/6fd891e0-ce75-462e-b4eb-a59aed75ce93.png)** | ![](img/22ac4a64-43bd-401c-92b7-a91376a60576.png) | ![](img/8795d96c-8164-4074-a370-586d0a1ff9a0.png) |
| 对 | G | 0.8 | +1 | 0.8 x 1 = 0.8 |
| 对 | C | 0.1 | 0 | 0.1 x 0 = 0 |
| 对 | X | 0.1 | 0 | 0.1 x 0 = 0 |
| **动作** | `s'` | ![](img/6fd891e0-ce75-462e-b4eb-a59aed75ce93.png) | ![](img/22ac4a64-43bd-401c-92b7-a91376a60576.png) | ![](img/8795d96c-8164-4074-a370-586d0a1ff9a0.png) |
| `RIGHT` | G | 0.8 | +1 | 0.8 x 1 = 0.8 |
| `RIGHT` | C | 0.1 | 0 | 0.1 x 0 = 0 |
| `RIGHT` | X | 0.1 | 0 | 0.1 x 0 = 0 |
因此，对于动作 *a = RIGHT* ，
因此，对于动作`a = RIGHT`，
![](img/42781834-798e-4673-a3ac-1b5601553691.png)
| **行动** | **s'** | **![](img/001a79e8-232c-416c-b1e7-c8d89cb12a90.png)** | ![](img/9a391f2f-337e-46c8-b314-7be8f2e1effa.png) | ![](img/8eb44a6d-f977-4086-b239-2e592f166cbf.png) |
| 下 | C | 0.8 | 0 | 0.8 x 0 = 0 |
| 下 | G | 0.1 | +1 | 0.1 x 1 = 0.1 |
| 下 | 一种 | 0.1 | 0 | 0.1 x 0 = 0 |
| **动作** | `s'` | ![](img/001a79e8-232c-416c-b1e7-c8d89cb12a90.png) | ![](img/9a391f2f-337e-46c8-b314-7be8f2e1effa.png) | ![](img/8eb44a6d-f977-4086-b239-2e592f166cbf.png) |
| `DOWN` | C | 0.8 | 0 | 0.8 x 0 = 0 |
| `DOWN` | G | 0.1 | +1 | 0.1 x 1 = 0.1 |
| `DOWN` | 一种 | 0.1 | 0 | 0.1 x 0 = 0 |
因此，对于动作 *a = DOWN* ，
因此，对于动作`a = DOWN`，
![](img/77918404-8e8e-4efa-9b97-1001d8bc8f4c.png)
| **行动** | **s'** | **![](img/acc2cb11-44c3-4325-9daa-68fe740d67cd.png)** | ![](img/b16f854f-055d-4ad4-898f-d6a84b08a775.png) | ![](img/55c7b3a8-f1c9-4e3f-ba20-69dcb80d4244.png) |
| 向上 | X | 0.8 | 0 | 0.8 x 0 = 0 |
| 向上 | G | 0.1 | +1 | 0.1 x 1 = 0.1 |
| 向上 | 一种 | 0.1 | 0 | 0.1 x 0 = 0 |
| **动作** | `s'` | ![](img/acc2cb11-44c3-4325-9daa-68fe740d67cd.png) | ![](img/b16f854f-055d-4ad4-898f-d6a84b08a775.png) | ![](img/55c7b3a8-f1c9-4e3f-ba20-69dcb80d4244.png) |
| `UP` | X | 0.8 | 0 | 0.8 x 0 = 0 |
| `UP` | G | 0.1 | +1 | 0.1 x 1 = 0.1 |
| `UP` | 一种 | 0.1 | 0 | 0.1 x 0 = 0 |
因此，对于动作 *a = UP* ，
因此，对于动作`a = UP`，
![](img/98b807be-a36f-472a-97d1-0dad9bf4f92e.png)
| **行动** | **s'** | ![](img/782bf5ec-3014-40c2-803d-dd2163340c53.png) | ![](img/90de6f01-fb3e-4558-b557-520defc86bab.png) | ![](img/7817ee4f-64fd-44ba-b2c4-7ad635cea69e.png) |
| 剩下 | 一种 | 0.8 | 0 | 0.8 x 0 = 0 |
| 剩下 | X | 0.1 | 0 | 0.1 x 0 = 0 |
| 剩下 | C | 0.1 | 0 | 0.1 x 0 = 0 |
| **动作** | `s'` | ![](img/782bf5ec-3014-40c2-803d-dd2163340c53.png) | ![](img/90de6f01-fb3e-4558-b557-520defc86bab.png) | ![](img/7817ee4f-64fd-44ba-b2c4-7ad635cea69e.png) |
| `LEFT` | 一种 | 0.8 | 0 | 0.8 x 0 = 0 |
| `LEFT` | X | 0.1 | 0 | 0.1 x 0 = 0 |
| `LEFT` | C | 0.1 | 0 | 0.1 x 0 = 0 |
因此，对于动作 *a =左*，
因此，对于动作`a = LEFT`，
![](img/9813b6c4-66cf-4dac-8764-0583ad1fff5f.png)
......@@ -304,41 +304,41 @@ MDP 试图通过将网格划分为状态，动作，模型/转换模型和奖励
![](img/bc2a8cef-a5a1-439c-a602-9d309920ca8d.png)。
*R（X）= -0.04*
`R(X) = -0.04`
| **行动** | **s'** | **![](img/7eab76d9-3bb5-4e5c-baf6-76ac3ab4e7d7.png)** | ![](img/22ac4a64-43bd-401c-92b7-a91376a60576.png) | ![](img/8795d96c-8164-4074-a370-586d0a1ff9a0.png) |
| 对 | G | 0.8 | +1 | 0.8 x 1 = 0.8 |
| 对 | C | 0.1 | -0.04 | 0.1 x -0.04 = -0.004 |
| 对 | X | 0.1 | 0.36 | 0.1 x 0.36 = 0.036 |
| **动作** | `s'` | ![](img/7eab76d9-3bb5-4e5c-baf6-76ac3ab4e7d7.png) | ![](img/22ac4a64-43bd-401c-92b7-a91376a60576.png) | ![](img/8795d96c-8164-4074-a370-586d0a1ff9a0.png) |
| `RIGHT` | G | 0.8 | +1 | 0.8 x 1 = 0.8 |
| `RIGHT` | C | 0.1 | -0.04 | 0.1 x -0.04 = -0.004 |
| `RIGHT` | X | 0.1 | 0.36 | 0.1 x 0.36 = 0.036 |
因此，对于动作 *a = RIGHT* ，
因此，对于动作`a = RIGHT`，
![](img/8eabbfa6-ba45-4387-82fd-804d44792a6d.png)
| **行动** | **s'** | **![](img/59516b7d-b5b9-4309-abff-a42760a70dbd.png)** | ![](img/9a391f2f-337e-46c8-b314-7be8f2e1effa.png) | ![](img/8eb44a6d-f977-4086-b239-2e592f166cbf.png) |
| 下 | C | 0.8 | -0.04 | 0.8 x -0.04 = -0.032 |
| 下 | G | 0.1 | +1 | 0.1 x 1 = 0.1 |
| 下 | 一种 | 0.1 | -0.04 | 0.1 x -0.04 = -0.004 |
| **动作** | `s'` | ![](img/59516b7d-b5b9-4309-abff-a42760a70dbd.png) | ![](img/9a391f2f-337e-46c8-b314-7be8f2e1effa.png) | ![](img/8eb44a6d-f977-4086-b239-2e592f166cbf.png) |
| `DOWN` | C | 0.8 | -0.04 | 0.8 x -0.04 = -0.032 |
| `DOWN` | G | 0.1 | +1 | 0.1 x 1 = 0.1 |
| `DOWN` | A | 0.1 | -0.04 | 0.1 x -0.04 = -0.004 |
因此，对于动作 *a = DOWN* ，
因此，对于动作`a = DOWN`，
![](img/bf1e83c6-52e3-46d9-91fb-6be453900357.png)
| **行动** | **s'** | **![](img/aeb2ed22-fa4e-4c2d-9a9d-247d56150c02.png)** | ![](img/b16f854f-055d-4ad4-898f-d6a84b08a775.png) | ![](img/55c7b3a8-f1c9-4e3f-ba20-69dcb80d4244.png) |
| 向上 | X | 0.8 | 0.36 | 0.8 x 0.36 = 0.288 |
| 向上 | G | 0.1 | +1 | 0.1 x 1 = 0.1 |
| 向上 | 一种 | 0.1 | -0.04 | 0.1 x -0.04 = -0.004 |
| **动作** | `s'` | ![](img/aeb2ed22-fa4e-4c2d-9a9d-247d56150c02.png) | ![](img/b16f854f-055d-4ad4-898f-d6a84b08a775.png) | ![](img/55c7b3a8-f1c9-4e3f-ba20-69dcb80d4244.png) |
| `UP` | X | 0.8 | 0.36 | 0.8 x 0.36 = 0.288 |
| `UP` | G | 0.1 | +1 | 0.1 x 1 = 0.1 |
| `UP` | 一种 | 0.1 | -0.04 | 0.1 x -0.04 = -0.004 |
因此，对于动作 *a = UP* ，
因此，对于动作`a = UP`，
![](img/a1393b1e-af2c-4d45-a9d3-9f939826c082.png)
| **行动** | **s'** | **![](img/cafa86c3-0a4d-46b0-ade6-eb54a20d65f5.png)** | ![](img/90de6f01-fb3e-4558-b557-520defc86bab.png) | ![](img/7817ee4f-64fd-44ba-b2c4-7ad635cea69e.png) |
| 剩下 | 一种 | 0.8 | -0.04 | 0.8 x -0.04 = -0.032 |
| 剩下 | X | 0.1 | 0.36 | 0.1 x 0.36 = 0.036 |
| 剩下 | C | 0.1 | -0.04 | 0.1 x -0.04 = -0.004 |
| **动作** | `s'` | ![](img/cafa86c3-0a4d-46b0-ade6-eb54a20d65f5.png) | ![](img/90de6f01-fb3e-4558-b557-520defc86bab.png) | ![](img/7817ee4f-64fd-44ba-b2c4-7ad635cea69e.png) |
| `LEFT` | 一种 | 0.8 | -0.04 | 0.8 x -0.04 = -0.032 |
| `LEFT` | X | 0.1 | 0.36 | 0.1 x 0.36 = 0.036 |
| `LEFT` | C | 0.1 | -0.04 | 0.1 x -0.04 = -0.004 |
因此，对于动作 *a =左*，
因此，对于动作`a = LEFT`，
![](img/6b4a7765-353e-41bd-9d1d-b0d911f5fcb8.png)
......@@ -368,15 +368,15 @@ MDP 试图通过将网格划分为状态，动作，模型/转换模型和奖励
# 部分可观察的马尔可夫决策过程
在 MDP 中，可观察的数量是动作，设置`A`，状态，设置`S`，过渡模型，`T`和奖励，设置`R`。 在**部分可观察的 MDP** （也称为 **POMDP**）的情况下，情况并非如此。 在 POMDP 中，内部存在一个 MDP，代理无法直接观察到它，而是根据所做的任何观察来做出决定。
在 MDP 中，可观察的数量是动作，设置`A`，状态，设置`S`，过渡模型，`T`和奖励，设置`R`。 在**部分可观察的 MDP**（也称为 **POMDP**）的情况下，情况并非如此。 在 POMDP 中，内部存在一个 MDP，代理无法直接观察到它，而是根据所做的任何观察来做出决定。
在 POMDP 中，有一个观测集`Z`，它包含不同的可观测状态和观测函数`O`，它采用`s`状态和`z`观察值作为输入，输出在`s`状态下看到`z`观察值的可能性。
POMDP 基本上是 MDP 的概括：
* **MDP**：{S，A，T，R}
* **MDP**：`{S, A, T, R}`
* **POMDP**：{S，A，Z，T，R，O}
* **POMDP**：`{S, A, Z, T, R, O}`
* 其中，S，A，T 和 R 相同。 因此，要使 POMDP 成为真正的 MDP，请满足以下条件：
......@@ -388,13 +388,13 @@ POMDP 难以解决，无法实现最佳解决方案。
# 状态估计
如果我们扩展状态空间，这将有助于我们将 POMDP 转换为 MDP，其中`Z`包含完全可观察的状态空间。 这给出了**信念状态 b [s]** 的概念，这是决策者将在 POMDP 上下文中使用的状态。 置信状态，即 *b（s）*给出了代理处于`s`状态的可能性。 因此，置信状态`b`，是代表所有状态上概率分布的向量。 因此，一旦采取行动，信念状态就会更新。
如果我们扩展状态空间，这将有助于我们将 POMDP 转换为 MDP，其中`Z`包含完全可观察的状态空间。 这给出了**信念状态**`b(s)`的概念，这是决策者将在 POMDP 上下文中使用的状态。 置信状态，即`b(s)`给出了代理处于`s`状态的可能性。 因此，置信状态`b`，是代表所有状态上概率分布的向量。 因此，一旦采取行动，信念状态就会更新。
假设存在一个信念状态`b`，该代理采取行动`a`并收到了一些观察结果`z`。 这形成了一个新的信念状态。 因此，我们正在将 POMDP 转换为信念 MDP，其中它将由信念状态组成为 MDP 状态。
根据前述条件，给出的信息是置信状态`b`，动作`a`和观察值`z`。 因此，
*b'（s'）* =在`b`，`a`，`z`之后给出的处于`s`状态的概率 ，即 *p（s'| b，a，z）*
`b'(s')`为在`b`，`a`，`z`之后给出的处于`s`状态的概率 ，即`P(s' | b, a, z)`。
![](img/35b5669e-32a7-4c9f-ad01-833abdb38255.png)
......@@ -406,23 +406,23 @@ POMDP 难以解决，无法实现最佳解决方案。
POMDP 中的值迭代基本上是从信念 MDP 获得的无限状态空间上的值迭代。
在 *t = 0* 时，![](img/c22745a1-9dba-415d-8af4-0b69ae458763.png)
在`t = 0`时，![](img/c22745a1-9dba-415d-8af4-0b69ae458763.png)
在 *t > 0* ，![](img/d9d073a1-0957-434c-962a-fc558a1bec1c.png)处，其中 *b'*为 *b'（s'）= p（s'| b，a，z）*，即*（b，a，z）*和 *R（b，a）*的状态估计是对信念状态的预期奖励，如下所示：
在`t > 0`，![](img/d9d073a1-0957-434c-962a-fc558a1bec1c.png)处，其中`b'`为`b'(s') = p(s' | b, a, z)`，即`(b, a, z)`和`R(b, a)`的状态估计是对信念状态的预期奖励，如下所示：
![](img/76b35625-61ca-47bf-b1f7-a0b13e381607.png)
哪里，
*p（s）* =`s`状态的概率
`p(s)`为`s`状态的概率
*R（s，a）* =该状态下的奖励
`R(s, a)`为该状态下的奖励
![](img/c113e9fc-da9e-4c29-a01a-ae92779162cf.png) =对信念状态的预期奖励
# 使用 MDP 训练 FrozenLake-v0 环境
这是关于 OpenAI 体育馆中名为 **FrozenLake-v0** 的网格世界环境，在第 2 章和*中讨论了使用 OpenAI 体育馆*训练强化学习代理。 我们实施了 Q 学习和 Q 网络（我们将在以后的章节中进行讨论）以了解 OpenAI 体育馆的环境。
这是关于 OpenAI 体育馆中名为 **FrozenLake-v0** 的网格世界环境，在第 2 章“使用 OpenAI 体育馆训练强化学习智能体”中讨论。 我们实施了 Q 学习和 Q 网络（我们将在以后的章节中进行讨论）以了解 OpenAI 体育馆的环境。
现在，让我们尝试使用以下代码实现值迭代，以获取 FrozenLake-v0 环境中每个状态的效用值：
......@@ -522,63 +522,63 @@ After learning completion printing the utilities for each states below from stat
我们代理的起始状态为 0。让我们从 s = 0 开始，
*U [s = 0] = 0.023482* ，现在动作可以是*上*，*下*，*左*或*右* 。
`U[s = 0] = 0.023482`，现在动作可以是`UP`，`DOWN`，`LEFT`或`RIGHT` 。
在 *s = 0* 的情况下，如果：
在`s = 0`的情况下，如果：
* 采取*向上*的操作， *s_new = o* ，因此， *u [s_new] = 0.023482*
* 采取*向下*的动作， *s_new = 4* ，因此， *u [s_new] = 0.0415207*
* 采取 *LEF* T 动作， *s_new = o* ，因此， *u [s_new] = 0.023482*
* 采取*右*的操作， *s_new = 1* ，因此， *u [s_new] = 0.00999637*
* 采取`UP`动作，`s_new = o`，因此，`u[s_new] = 0.023482`
* 采取`DOWN`动作，`s_new = 4`，因此，`u[s_new] = 0.0415207`
* 采取`LEFT`动作，`s_new = o`，因此，`u[s_new] = 0.023482`
* 采取`RIGHT`动作，`s_new = 1`，因此，`u[s_new] = 0.00999637`
最大值为 *u [s_new = 4] = 0.0415207* ，因此，采取的措施为 *DOWN* 和 *s_new = 4* 。
最大值为`u[s_new = 4] = 0.0415207`，因此，采取的动作为`DOWN`和`s_new = 4`。
现在在 *s = 4* 的情况下：
现在在`s = 4`的情况下：
* 采取*向上*的操作， *s_new = o* ，因此， *u [s_new] = 0.023482*
* 采取*向下*动作， *s_new = 8* ，因此， *u [s_new] = 0.09109598*
* 采取*左移*动作， *s_new = 4* ，因此， *u [s_new] = 0.0415207*
* 采取*右*的操作， *s_new = 5* ，因此， *u [s_new] = -1.0*
* 采取`UP`动作，`s_new = o`，因此，`u[s_new] = 0.023482`
* 采取`DOWN`动作，`s_new = 8`，因此，`u[s_new] = 0.09109598`
* 采取`LEFT`动作，`s_new = 4`，因此，`u[s_new] = 0.0415207`
* 采取`RIGHT`动作，`s_new = 5`，因此，`u[s_new] = -1.0`
最大值为 *u [s_new = 8] = 0.09109598* ，则采取的动作将为 *DOWN* 和 *s_new = 8* 。
最大值为`u[s_new = 8] = 0.09109598`，则采取的动作将为`DOWN`和`s_new = 8`。
现在，如果 *s = 8* ，则：
现在，如果`s = 8`，则：
* 采取 *UP* 动作， *s_new = 4* ，因此， *u [s_new] = 0.0415207*
* 采取*向下*动作， *s_new = 12* ，因此， *u [s_new] = -1.0*
* 动作*左移*， *s_new = 8* ，因此， *u [s_new] = 0.09109598*
* 采取*右*的操作， *s_new = 9* ，因此， *u [s_new] = 0.20932556*
* 采取`UP`动作，`s_new = 4`，因此，`u[s_new] = 0.0415207`
* 采取`DOWN`动作，`s_new = 12`，因此，`u[s_new] = -1.0`
* 采取`LEFT`动作，`s_new = 8`，因此，`u[s_new] = 0.09109598`
* 采取`RIGHT`动作，`s_new = 9`，因此，`u[s_new] = 0.20932556`
最大值为 *u [s_new = 9] = 0.20932556* ，因此，采取的措施为 *RIGHT* 和 *s_new = 9* 。
最大值为`u[s_new = 9] = 0.20932556`，因此，采取的动作为`RIGHT`和`s_new = 9`。
现在，如果 *s = 9* ，则：
现在，如果`s = 9`，则：
* 采取 *UP* 动作， *s_new = 5* ，因此， *u [s_new] = -1.0*
* 采取*向下*动作， *s_new = 13* ，因此， *u [s_new] = 0.43048408*
* 动作*左移*， *s_new = 8* ，因此， *u [s_new] = 0.09109598*
* 采取*右*的操作， *s_new = 10* ，因此， *u [s_new] = 0.26362693*
* 采取`UP`动作，`s_new = 5`，因此，`u[s_new] = -1.0`
* 采取`DOWN`动作，`s_new = 13`，因此，`u[s_new] = 0.43048408`
* 采取`LEFT`动作，`s_new = 8`，因此，`u[s_new] = 0.09109598`
* 采取`RIGHT`动作，`s_new = 10`，因此，`u[s_new] = 0.26362693`
最大值为 *u [s_new = 13] = 0.43048408* ，因此，采取的措施为 *DOWN* 和 *s_new = 13* 。
最大值为`u[s_new = 13] = 0.43048408`，因此，采取的动作为`DOWN`和`s_new = 13`。
现在，如果 *s = 13* ，则：
现在，如果`s = 13`，则：
* 采取 *UP* 动作， *s_new = 9* ，因此， *u [s_new] = 0.20932556*
* 按下*向下*动作，则 *s_new = 13* ，因此， *u [s_new] = 0.43048408*
* 动作*左移*， *s_new = 12* ，因此， *u [s_new] = -1.0*
* 采取*右*的操作， *s_new = 14* ，因此， *u [s_new] = 0.97468581*
* 采取`UP`动作，`s_new = 9`，因此，`u[s_new] = 0.20932556`
* 采取`DOWN`动作，则`s_new = 13`，因此，`u[s_new] = 0.43048408`
* 采取`LEFT`动作，`s_new = 12`，因此，`u[s_new] = -1.0`
* 采取`RIGHT`动作，`s_new = 14`，因此，`u[s_new] = 0.97468581`
最大值为 *u [s_new = 14] =* 0.97468581，因此，采取的措施为 *RIGHT* 和 *s_new = 14* 。
最大值为`u[s_new = 14] = 0.97468581`，因此，采取的动作为`RIGHT`和`s_new = 14`。
现在，如果 *s = 14* ，则：
现在，如果`s = 14`，则：
* 采取*向上*的操作， *s_new = 10* ，因此， *u [s_new] = 0.26362693*
* 采取*向下*的操作， *s_new = 14* ，因此， *u [s_new] = 0.97468581*
* 采取*向左*的操作， *s_new = 13* ，因此， *u [s_new] = 0.43048408*
* 采取*右*的操作， *s_new = 15（目标状态）*，因此， *u [s_new] = 1.0*
* 采取`UP`动作，`s_new = 10`，因此，`u[s_new] = 0.26362693`
* 采取`DOWN`动作，`s_new = 14`，因此，`u[s_new] = 0.97468581`
* 采取`LEFT`动作，`s_new = 13`，因此，`u[s_new] = 0.43048408`
* 采取`RIGHT`动作，`s_new = 15`（目标状态），因此，`u[s_new] = 1.0`
最大值为 *u [s_new = 15] =* *1.0* ，因此，采取的措施为 *RIGHT* 和 *s_new = 15* 。
最大值为`u [s_new = 15] = 1.0`，因此，采取的动作为`RIGHT`和`s_new = 15`。
因此，我们的策略包含 *DOWN* ， *DOWN* ， *RIGHT* ， *DOWN* ， *RIGHT* 和 *RIGHT* 通过避开空穴状态（5、7、11、12）从 *s = 0（开始状态）*到达 *s = 15（目标状态）*。
因此，我们的策略包含`DOWN`，`DOWN`，`RIGHT`，`DOWN`，`RIGHT`和`RIGHT`通过避开空穴状态（5、7、11、12）从`s = 0`（开始状态）到达`s = 15`（目标状态）。
# 概要
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或