目录
前言
学习赵老师讲授的强化学习的数学原理视频，本篇文章记录第四讲 Part 3：值迭代与策略迭代（截断策略迭代算法），记录个人学习笔记，和大家一起分享交流😄
1. Compare value iteration and policy iteration
前面我们介绍了 policy iteration 和 value iteration 这两个算法，下面我们来介绍第三个算法 truncated policy iteration。
在开始之前我想强调的是，第三个算法实际上并不是一个全新的算法，而是 value iteration 和 policy iteration 这两个算法的一般化推广 。之后大家就会明白， value iteration 和 policy iteration 这两个算法，实际上是 truncated policy iteration 的两个特殊情况。
我们在介绍这个算法的过程中会反复比较 value iteration 和 policy iteration，所以这部分非常重要。我们首先来比较一下之前学过的这两个算法。
针对 policy iteration ，它是从一个初始的策略 π 0 \pi_0 π0 出发，这个策略可能是任意给定的（甚至可能非常不好），然后在第 k k k 个 iteration 当中它包含如下两个步骤：
Policy evaluation（PE）：
v π k = r π k + γ P π k v π k v_{\pi_k} = r_{\pi_k} + \gamma P_{\pi_k} v_{\pi_k} vπk=rπk+γPπkvπk
Policy improvement（PI）：
π k + 1 = arg max π ( r π + γ P π v π k ) \pi_{k+1} = \arg \max_{\pi}(r_{\pi} + \gamma P_{\pi}v_{\pi_k}) πk+1=argπmax(rπ+γPπvπk)
第一个是 policy evaluation ，也就是：在第 k k k 步中给定策略 π k \pi_k πk ，求解 贝尔曼公式 ，得到 v π k v_{\pi_k} vπk 。
第二个步骤是 policy improvement ，我们刚才不是求出来这个 v π k v_{\pi_k} vπk 了吗？然后再求解 arg max π \arg \max_{\pi} argmaxπ 这样一个优化式子，就可以得到一个新的策略 π k + 1 \pi_{k+1} πk+1 ，然后再不断地迭代下去。这些内容我们前面都已经介绍过了，所以这里就快速带过。
value iteration 与 policy iteration 的一个区别是，它不是从一个策略 π 0 \pi_0 π0 出发，而是 从一个值 v 0 v_0 v0 出发 （ v 0 v_0 v0 可以是任意值），通过迭代最终收敛到 v ∗ v^* v∗ ，也就是 optimal state value 。在第 k k k 个 iteration 中，它包含如下两个部分：
Policy update（PU）：
π k + 1 = arg max π ( r π + γ P π v k ) \pi_{k+1} = \arg \max_{\pi} (r_{\pi} + \gamma P_{\pi} v_k) πk+1=argπmax(rπ+γPπvk)
Value update（VU）：
v k + 1 = r π k + 1 + γ P π k + 1 v k v_{k+1} = r_{\pi_{k+1}} + \gamma P_{\pi_{k+1}} v_k vk+1=rπk+1+γPπk+1vk
第一个是 policy update ，这一步做什么呢？在第 k k k 步中我们已经知道了 v k v_k vk ，然后求解 arg max π \arg \max_{\pi} argmaxπ 这样一个优化的式子，就可以得到 π k + 1 \pi_{k+1} πk+1 ，一个新的策略。
第二个步骤就是 value update ，已知 π k + 1 \pi_{k+1} πk+1 ，就能得到 r π k + 1 r_{\pi_{k+1}} rπk+1 和 P π k + 1 P_{\pi_{k+1}} Pπk+1 ，再结合已有的 v k v_k vk ，一步求出 v k + 1 v_{k+1} vk+1 ，然后再这样不断地迭代下去。
到这里，相信有些同学已经发现了， policy iteration 与 value iteration 是非常类似的，为了比较它们我们来看一下下面这个形式：
Policy iteration: π 0 → P E v π 0 → P I π 1 → P E v π 1 → P I π 2 → P E v π 2 → P I ⋯ Value iteration: π 0 → P E u 0 → P U π 1 ′ → V U u 1 → P U π 2 ′ → V U u 2 → P U ⋯ \begin{array}{ll} \text{Policy iteration:} & \pi_0 \xrightarrow{PE} v_{\pi_0} \xrightarrow{PI} \pi_1 \xrightarrow{PE} v_{\pi_1} \xrightarrow{PI} \pi_2 \xrightarrow{PE} v_{\pi_2} \xrightarrow{PI} \cdots \\6pt \text{Value iteration:} & \phantom{\pi_0 \xrightarrow{PE} {}}u_0 \xrightarrow{PU} \pi_1' \xrightarrow{VU} u_1 \xrightarrow{PU} \pi_2' \xrightarrow{VU} u_2 \xrightarrow{PU} \cdots \end{array} Policy iteration:Value iteration:π0PE vπ0PI π1PE vπ1PI π2PE vπ2PI ⋯π0PE u0PU π1′VU u1PU π2′VU u2PU ⋯
首先第一行是 policy iteration ，它最开始从一个策略 π 0 \pi_0 π0 出发，然后做 policy evaluation（PE） 得到 v π 0 v_{\pi_0} vπ0 ，做 policy improvement 得到这个 π 1 \pi_1 π1 ，接着不断循环迭代得到 v π 1 , π 2 , v π 2 , ... v_{\pi_1},\pi_2,v_{\pi_2},\ldots vπ1,π2,vπ2,... 。
然后第二行是 value iteration ，value iteration 最初从一个值出发，我们这里用 u 0 u_0 u0 来表示，最开始它没有初始策略，为了比较这两个算法，我们强行把它们上下对齐，从 u 0 u_0 u0 出发我做 policy update（PU） 得到一个新的策略 π 1 ′ \pi_1' π1′ ，然后做 value update（VU） 再得到一个新的值 u 1 u_1 u1 ，接着不断循环迭代，依次得到新策略和新值。
所以这两个算法其实是非常类似的，那么它们的 区别究竟是什么呢？ 这个问题非常关键，也是引出 truncated policy iteration 的核心问题，我们下面来详细看一下。
| 策略迭代算法 | 值迭代算法 | 注释 | |
|---|---|---|---|
| 1) 策略： | π 0 \pi_0 π0 | N/A | |
| 2) 价值： | v π 0 = r π 0 + γ P π 0 v π 0 v_{\pi_0} = r_{\pi_0} + \gamma P_{\pi_0}v_{\pi_0} vπ0=rπ0+γPπ0vπ0 | v 0 : = v π 0 \textcolor{red}{v_0 := v_{\pi_0}} v0:=vπ0 | |
| 3) 策略： | π 1 = arg max π ( r π + γ P π v π 0 ) \pi_1 = \arg\max_\pi (r_\pi + \gamma P_\pi v_{\pi_0}) π1=argmaxπ(rπ+γPπvπ0) | π 1 = arg max π ( r π + γ P π v 0 ) \pi_1 = \arg\max_\pi (r_\pi + \gamma P_\pi v_0) π1=argmaxπ(rπ+γPπv0) | 两个策略相同 |
| 4) 价值： | v π 1 = r π 1 + γ P π 1 v π 1 \textcolor{blue}{v_{\pi_1} = r_{\pi_1} + \gamma P_{\pi_1}v_{\pi_1}} vπ1=rπ1+γPπ1vπ1 | v 1 = r π 1 + γ P π 1 v 0 \textcolor{blue}{v_1 = r_{\pi_1} + \gamma P_{\pi_1} v_0} v1=rπ1+γPπ1v0 | v π 1 ≥ v 1 v_{\pi_1} \ge v_1 vπ1≥v1 ，因为 v π 1 ≥ v π 0 v_{\pi_1} \ge v_{\pi_0} vπ1≥vπ0 |
| 5) 策略： | π 2 = arg max π ( r π + γ P π v π 1 ) \pi_2 = \arg\max_\pi (r_\pi + \gamma P_\pi v_{\pi_1}) π2=argmaxπ(rπ+γPπvπ1) | π 2 ′ = arg max π ( r π + γ P π v 1 ) \pi_2' = \arg\max_\pi (r_\pi + \gamma P_\pi v_1) π2′=argmaxπ(rπ+γPπv1) | |
| ⋮ \vdots ⋮ | ⋮ \vdots ⋮ | ⋮ \vdots ⋮ | ⋮ \vdots ⋮ |
第一步针对策略的操作：policy iteration 给定一个初始策略 π 0 \pi_0 π0 ， value iteration 这时还没开始，因为它最初没有初始的策略，它只有初始的值。
然后第二步对 value 的操作， policy iteration 实际上刚才不是给定了初始策略 π 0 \pi_0 π0 吗？下面要求出 v π 0 v_{\pi_0} vπ0 ，通过求解 贝尔曼公式 。而 value iteration 在这一步并没有计算---它的初始值 v 0 v_0 v0 早已给定，为了让这两个算法具有可比性，我们 强行地让 v 0 = v π 0 v_0=v_{\pi_0} v0=vπ0 。
实际上 value iteration 的初始值可以是任意的，但如果两个算法从不同的初始值出发，就没法公平比较了，所以这里让 v 0 = v π 0 v_0=v_{\pi_0} v0=vπ0 。
然后第三步对 policy 的操作， policy iteration 刚才不是求出来 v π 0 v_{\pi_0} vπ0 了吗？然后我求解 arg max π \arg \max_{\pi} argmaxπ 这样一个优化得到一个新的策略 π 1 \pi_1 π1 。而 value iteration 实际上是很类似的，它已经有一个 v 0 v_0 v0 ，求解同样的优化问题，得到的新策略也是 π 1 \pi_1 π1 ，为什么呢？
因为刚才为了比较，我让 v 0 v_0 v0 强行等于 v π 0 v_{\pi_0} vπ0 ，所以这一步这两个算法还是一致的， 到目前为止这两个算法的每一步实际上都是相同的。
到第四步的时候就出现了不同，怎么个不同法呢？我们来看 policy iteration ，刚才有了 π 1 \pi_1 π1 ，下面要求 v π 1 v_{\pi_1} vπ1 ，即求解 贝尔曼公式 。然后 value iteration 它在干嘛呢？我刚才有了这个 π 1 \pi_1 π1 ，所以 r π 1 , P π 1 r_{\pi_1},P_{\pi_1} rπ1,Pπ1 这些我都知道了，再加上已有的 v 0 v_0 v0 ，一步 就可以求出 v 1 v_1 v1 ，然后这个 v 1 v_1 v1 就立刻用到下一步当中，当然 v π 1 v_{\pi_1} vπ1 也会用于下一步，这时候 v 1 v_1 v1 和 v π 1 v_{\pi_1} vπ1 就已经不再相同了。
当然你再往下走的话，这些所得到的策略和值也都不同了，所以 关键是第四步 ： v π 1 v_{\pi_1} vπ1 和 v 1 v_1 v1 究竟有什么不同呢？
关于 policy iteration 的这一步，它要求解的是
v π 1 = r π 1 + γ P π 1 v π 1 v_{\pi_1} = r_{\pi_1} + \gamma P_{\pi_1}v_{\pi_1} vπ1=rπ1+γPπ1vπ1
这样一个 贝尔曼公式 ，我要求解出来 v π 1 v_{\pi_1} vπ1 ，怎么求解呢？我需要一个 内嵌的迭代算法，这个之前我们都已经介绍过了，我把这个内嵌的迭代算法详细地写到下面，让大家一目了然：
v π 1 ( 0 ) = v 0 v π 1 ( 1 ) = r π 1 + γ P π 1 v π 1 ( 0 ) v π 1 ( 2 ) = r π 1 + γ P π 1 v π 1 ( 1 ) ⋮ v π 1 ( j ) = r π 1 + γ P π 1 v π 1 ( j − 1 ) ⋮ v π 1 ( ∞ ) = r π 1 + γ P π 1 v π 1 ( ∞ ) \begin{aligned} \textcolor{red}{v_{\pi_1}^{(0)}} &= \textcolor{red}{v_0} \\ v_{\pi_1}^{(1)} &= r_{\pi_1} + \gamma P_{\pi_1} v_{\pi_1}^{(0)} \\ v_{\pi_1}^{(2)} &= r_{\pi_1} + \gamma P_{\pi_1} v_{\pi_1}^{(1)} \\ &\vdots \\ v_{\pi_1}^{(j)} &= r_{\pi_1} + \gamma P_{\pi_1} v_{\pi_1}^{(j-1)} \\ &\vdots \\ v_{\pi_1}^{(\infty)} &= r_{\pi_1} + \gamma P_{\pi_1} v_{\pi_1}^{(\infty)} \end{aligned} vπ1(0)vπ1(1)vπ1(2)vπ1(j)vπ1(∞)=v0=rπ1+γPπ1vπ1(0)=rπ1+γPπ1vπ1(1)⋮=rπ1+γPπ1vπ1(j−1)⋮=rπ1+γPπ1vπ1(∞)
我们简单地过一下，这里的 v π 1 ( 0 ) v_{\pi_1}^{(0)} vπ1(0) ，右上角的 ( 0 ) (0) (0) 代表什么呢？代表第 0 次估计， ( 1 ) (1) (1) 代表第 1 次估计，那么第 0 次估计可以从任意初始值出发，代入右边的公式得到 v π 1 ( 1 ) v_{\pi_1}^{(1)} vπ1(1) ，再代回得到 v π 1 ( 2 ) v_{\pi_1}^{(2)} vπ1(2) ，等等，一直到 v π 1 ( j ) v_{\pi_1}^{(j)} vπ1(j) 。
到最后我要计算无穷多次，右边就变成了 v π 1 ( ∞ ) v_{\pi_1}^{(\infty)} vπ1(∞) ，而左边实际上是 v π 1 ( ∞ + 1 ) v_{\pi_1}^{(\infty+1)} vπ1(∞+1) ，那 ∞ + 1 \infty +1 ∞+1 还是无穷，所以就得到上面这样一个式子，这是 典型的求解贝尔曼公式的迭代算法，这没有什么新东西。
但是下面我们来看一下新的东西要出现了，是什么呢？就是这个初始值。为了比较 policy iteration 和 value iteration ，我让内层求解贝尔曼公式的迭代也从 v 0 v_0 v0 出发（ v 0 v_0 v0 就是 value iteration 第二步使用的那个值，大家可以回到对比表格中查看）。
v π 1 ( 0 ) = v 0 value iteration ← v 1 ← v π 1 ( 1 ) = r π 1 + γ P π 1 v π 1 ( 0 ) v π 1 ( 2 ) = r π 1 + γ P π 1 v π 1 ( 1 ) ⋮ truncated policy iteration ← v ˉ 1 ← v π 1 ( j ) = r π 1 + γ P π 1 v π 1 ( j − 1 ) ⋮ policy iteration ← v π 1 ← v π 1 ( ∞ ) = r π 1 + γ P π 1 v π 1 ( ∞ ) \begin{array}{r c c c l} &&&& \textcolor{red}{v_{\pi_1}^{(0)} = v_0} \\4pt \text{value iteration} & \leftarrow & \textcolor{red}{v_1} & \textcolor{red}{\leftarrow} & v_{\pi_1}^{(1)} = r_{\pi_1} + \gamma P_{\pi_1}\, v_{\pi_1}^{(0)} \\4pt &&&& v_{\pi_1}^{(2)} = r_{\pi_1} + \gamma P_{\pi_1}\, v_{\pi_1}^{(1)} \\4pt &&&& \quad \vdots \\4pt \textcolor{red}{\text{truncated policy iteration}} & \leftarrow & \textcolor{red}{\bar{v}1} & \textcolor{red}{\leftarrow} & v{\pi_1}^{(j)} = r_{\pi_1} + \gamma P_{\pi_1}\, v_{\pi_1}^{(j-1)} \\4pt &&&& \quad \vdots \\4pt \text{policy iteration} & \leftarrow & \textcolor{red}{v_{\pi_1}} & \textcolor{red}{\leftarrow} & v_{\pi_1}^{(\infty)} = r_{\pi_1} + \gamma P_{\pi_1}\, v_{\pi_1}^{(\infty)} \end{array} value iterationtruncated policy iterationpolicy iteration←←←v1vˉ1vπ1←←←vπ1(0)=v0vπ1(1)=rπ1+γPπ1vπ1(0)vπ1(2)=rπ1+γPπ1vπ1(1)⋮vπ1(j)=rπ1+γPπ1vπ1(j−1)⋮vπ1(∞)=rπ1+γPπ1vπ1(∞)
如果 v π 1 ( 0 ) = v 0 v_{\pi_1}^{(0)}=v_0 vπ1(0)=v0 ，那么 v π 1 ( 1 ) v_{\pi_1}^{(1)} vπ1(1) 是什么呢？实际上就是 v 1 v_1 v1 ，也就是 value iteration 得到的值，然后它会把 v 1 v_1 v1 立刻用于下一步的 policy update。
那计算无穷多步得到的 v π 1 ( ∞ ) v_{\pi_1}^{(\infty)} vπ1(∞) 是什么呢？实际上就是这个 v π 1 v_{\pi_1} vπ1 ，所以现在就很清楚了，也就是说，在前面表格第四步中 value iteration 实际上只迭代计算了一步，而 policy iteration 需要迭代无穷多步 ，从而计算出 v π 1 v_{\pi_1} vπ1 。
那么我们自然能够想象到是否有一个中间步，比如说我只计算 j j j 次，把 v π 1 ( j ) v_{\pi_1}^{(j)} vπ1(j) 作为一个新的量，记作 v ˉ 1 \bar{v}_1 vˉ1 ，然后我把它作为一个新的值用于下一步的策略计算，那么这样一个思路，这样一个算法就叫 truncated policy iteration 。为什么叫 truncated ？就是因为从第 j j j 步到无穷的迭代全都被舍弃、被截断了。
所以 truncated policy iteration 显然是 value iteration 和 policy iteration 更一般化的形式 ，为什么呢？因为当 j = 1 j=1 j=1 的时候， truncated policy iteration 就变成了 value iteration ，当 j → ∞ j \to \infty j→∞ 的时候，它就变成了 policy iteration。
下面我还想强调一个点：policy iteration 这个算法它只在理论上存在，在实际当中是不可能存在的 ，因为它需要计算无穷多步，在实际当中怎么可能计算无穷多步呢？常见的做法是：判断 v π 1 ( j ) v_{\pi_1}^{(j)} vπ1(j) 与 v π 1 ( j − 1 ) v_{\pi_1}^{(j-1)} vπ1(j−1) 之间的误差是否已经足够小，误差足够小就停止迭代。但即便如此，计算的仍是有限步。
所以在实际当中，其实我们想要计算 policy iteration ，它本质上也一定是 "截断的" policy iteration ，因此 truncated policy iteration 非常重要，这就是刚才要强调的点。
2. Truncated policy iteration
下面这个是 truncated policy iteration 的 pseudocode：
伪代码：截断策略迭代算法
初始化 ：已知所有 ( s , a ) (s, a) (s,a) 的概率模型 p ( r ∣ s , a ) p(r|s, a) p(r∣s,a) 和 p ( s ′ ∣ s , a ) p(s'|s, a) p(s′∣s,a) 。给出初始策略 π 0 \pi_0 π0 。
目标：搜索最优状态价值和最优策略。
当 策略尚未收敛时，在第 k k k 次迭代中，执行：
策略评估：
初始化：选取初始值 v k ( 0 ) = v k − 1 v_{k}^{(0)}=v_{k-1} vk(0)=vk−1 。设置最大迭代次数为 j truncate j_{\text{truncate}} jtruncate 。
当 j < j truncate j < j_{\text{truncate}} j<jtruncate 时，执行：
对于 每个状态 s ∈ S s \in \mathcal{S} s∈S，执行：
v k ( j + 1 ) ( s ) = ∑ a π k ( a ∣ s ) ∑ r p ( r ∣ s , a ) r + γ ∑ s ′ p ( s ′ ∣ s , a ) v k ( j ) ( s ′ ) v_{k}^{(j+1)}(s) = \sum_a \pi_k(a|s) \left \\sum_r p(r\|s,a)r + \\gamma \\sum_{s'} p(s'\|s,a)v_{k}\^{(j)}(s') \\right vk(j+1)(s)=a∑πk(a∣s)r∑p(r∣s,a)r+γs′∑p(s′∣s,a)vk(j)(s′)
设置 v k = v k ( j truncate ) v_k = v_k^{(j_{\text{truncate}})} vk=vk(jtruncate) 。
策略改进：
对于 每个状态 s ∈ S s \in \mathcal{S} s∈S，执行：
对于 每个动作 a ∈ A ( s ) a \in \mathcal{A}(s) a∈A(s)，执行：
q k ( s , a ) = ∑ r p ( r ∣ s , a ) r + γ ∑ s ′ p ( s ′ ∣ s , a ) v k ( s ′ ) q_{k}(s, a) = \sum_r p(r|s, a)r + \gamma \sum_{s'} p(s'|s, a)v_{k}(s') qk(s,a)=r∑p(r∣s,a)r+γs′∑p(s′∣s,a)vk(s′)
a k ∗ ( s ) = arg max a q k ( s , a ) a_k^*(s) = \arg\max_a q_{k}(s, a) ak∗(s)=argmaxaqk(s,a)
π k + 1 ( a ∣ s ) = { 1 若 a = a k ∗ 0 其他情况 \pi_{k+1}(a|s) = \begin{cases} 1 & \text{若 } a = a_k^* \\ 0 & \text{其他情况} \end{cases} πk+1(a∣s)={10若 a=ak∗其他情况
这个伪代码和前面 policy iteration 的伪代码几乎一模一样的，区别在于：内层循环不再判断 state value 是否收敛 ，而是判断 是否达到了预设的迭代次数 。比如事先设定参数 j truncate j_{\text{truncate}} jtruncate 为 1、2、100 或 1000 都可以，当 j < j truncate j < j_{\text{truncate}} j<jtruncate 时执行迭代，一旦 j j j 达到 j truncate j_{\text{truncate}} jtruncate 就停止。
内层循环结束后，把 v k ( j truncate ) v_k^{(j_{\text{truncate}})} vk(jtruncate) 作为新的值 v k v_k vk ，用于下一步的策略改进，那么 j truncate j_{\text{truncate}} jtruncate 这个参数该怎么选呢？之后我们会通过一个例子来说明。
这里其实有一个明显的问题：我们没有计算无穷多步，所以计算出来的 v k v_k vk 实际上 并不是 v π k v_{\pi_k} vπk ，那么这种截断是否会带来问题呢？比如说 是否会让整个算法不再收敛呢？
这个问题实际上回答起来是比较复杂的，那我们这里只给出一个比较简单的结论，从直观上给大家一些解释。
命题（价值提升）
考虑用于求解策略评估步骤的迭代算法：
v π k ( j + 1 ) = r π k + γ P π k v π k ( j ) , j = 0 , 1 , 2 , ... v_{\pi_k}^{(j+1)} = r_{\pi_k} + \gamma P_{\pi_k}v_{\pi_k}^{(j)}, \quad j = 0, 1, 2, \dots vπk(j+1)=rπk+γPπkvπk(j),j=0,1,2,...
如果初始值取为 v π k ( 0 ) = v π k − 1 v_{\pi_k}^{(0)} = v_{\pi_{k-1}} vπk(0)=vπk−1 ，那么可得：
v π k ( j + 1 ) ≥ v π k ( j ) v_{\pi_k}^{(j+1)} \ge v_{\pi_k}^{(j)} vπk(j+1)≥vπk(j)
对于每一个 j = 0 , 1 , 2 , ... j = 0, 1, 2, \dots j=0,1,2,... 均成立。
这个结果是什么呢？就是在求解 贝尔曼公式 的时候，不是有一个迭代算法吗？如果这个迭代算法的初始值比较特殊---取为 v π k − 1 v_{\pi_{k-1}} vπk−1 ---那么我们可以证明：在这个迭代算法中， v π k ( j + 1 ) v_{\pi_k}^{(j+1)} vπk(j+1) 一定不小于 v π k ( j ) v_{\pi_k}^{(j)} vπk(j)（逐分量）。
也就是说，无论计算一次、 j j j 次还是无穷多次，估计值都会增大，每多迭代一步，估计值就增大一步（逐分量）。由于估计值随迭代单调提升，而计算无穷多次代价又太大，所以不必做满，有限步就足够了。关于这个结果的证明，可以参考教材。
刚才的这个结果实际上可以通过下面这个图比较好地展示出来：
这个图的横轴是 k k k ，即外层 iteration 的索引，纵轴是值。为了简单起见，图中假设 state value 是一维的（标量），红线 v ∗ v^* v∗ 代表 optimal state value ，紫线 v k v_k vk 代表 value iteration ，从初始点出发得到的值不断收敛到 v ∗ v^* v∗ 。
蓝线 v π k v_{\pi_k} vπk 代表 policy iteration 算法，从相同的初始值出发，它也会逐渐收敛到 v ∗ v^* v∗ 。黑色的线代表 truncated policy iteration。
正如我们刚才所说，截断策略迭代只需计算有限步就能获得改进，所以在每一步，它的值比 value iteration 的 v k v_k vk 好，但比 policy iteration 的 v π k v_{\pi_k} vπk 稍差，所以 它正好夹在两者中间，既然蓝线和紫线都收敛，不难想象黑线也是收敛的。
3. Summary
以上就是本节课的全部内容，我们简要回顾一下：
首先我们介绍了 value iteration ，这个是在上节课当中由 contraction mapping theorem 给出来的一个算法，我们给它起了名字，把它分解成两个步骤（policy update 和 value update），正式地介绍出来。
第二个算法是 policy iteration ，这是今天新介绍的算法，希望大家明白这个算法非常重要，而且在下节课当中我们实际上就会在这个算法的基础上得到一个 model-free 的 RL 算法。
第三个算法是 truncated policy iteration ，现在我们知道 前两个算法（value iteration 和 policy iteration）正是它的两个极端特殊情况。
结语
本讲第三部分通过细致的对比分析，揭示了 value iteration 与 policy iteration 的本质区别：两者在前几步完全一致（只要让 v 0 = v π 0 v_0 = v_{\pi_0} v0=vπ0），分歧出现在 value 的计算上---value iteration 在内层迭代中只走一步（ v π 1 ( 1 ) v_{\pi_1}^{(1)} vπ1(1)），而 policy iteration 需要走无穷多步（ v π 1 ( ∞ ) v_{\pi_1}^{(\infty)} vπ1(∞)）才能精确求解贝尔曼公式。这一观察直接引出了更一般的 truncated policy iteration（截断策略迭代）：在内层迭代中只计算有限的 j truncate j_{\text{truncate}} jtruncate 步。
Truncated policy iteration 完美统一了前两个算法：当 j truncate = 1 j_{\text{truncate}}=1 jtruncate=1 时退化为 value iteration，当 j truncate → ∞ j_{\text{truncate}} \to \infty jtruncate→∞ 时即为 policy iteration。一个深刻的实践洞见是：纯 policy iteration 只存在于理论中---现实中任何 "判断收敛后停止" 的实现本质上都是截断的。价值提升命题保证了截断不会破坏算法的有效性：只要用上一轮的 v π k − 1 v_{\pi_{k-1}} vπk−1 作为内层迭代的初始值，每多算一步都能让估计值单调提升，因此截断迭代的收敛曲线恰好夹在 value iteration 与 policy iteration 之间。
至此，我们完成了第一个 model-based 算法家族的完整学习，下一讲将开启 model-free 强化学习的新篇章🤗。