ADPRL - 近似动态规划和强化学习 - Note 4 - Policy Iteration Algorithms

4. Policy Iteration Algorithms

在Note 3中，我们开发了解决无限范围MDP问题的VI算法。尽管该算法很简单，而且具有良好的理论收敛特性，但很明显，当状态空间很大时，该算法的效率会很低。VI算法实际上也变得不可行，因为它需要无限次地迭代以达到策略空间中的必要和充分的最优条件。此外，由于每个可接受的策略都有一个唯一的总成本函数，而唯一策略的总数是有限的，很明显，由VI算法产生的大多数总成本函数估计值并不对应于任何合法策略。换句话说，VI算法对于解决具有有限状态和行动空间的MDP问题来说，确实是非常低效的。因此，在本次会议上，我们研究了另一种解决该问题的方法，即在策略空间中搜索。

补充：范数的性质

在相关证明时,我们会利用到范数的性质，在这里作为补充。若 $X$ 是数域上的线性空间，泛函 $\Vert \cdot \Vert :X\to \mathbb{R}$ 满足:

1. 正定性: $\Vert x\Vert \ge 0$ ，且 $\Vert x\Vert =0\iff x=0$ ；
2. 正齐次性: $\Vert cx\Vert =|c|\Vert x\Vert$;
3. 次可加性 (三角不等式) : $\Vert x+y\Vert \le \Vert x\Vert +\Vert y\Vert$ 。

那么， $\Vert \cdot \Vert$ 称为 X 上的一个范数。

4.1 贪婪诱导策略的特性 （Properties of Greedily Induced Policy）

首先，让我们研究一下贪婪诱导策略的一些特性。

图1：贪婪诱导策略的直接误差界限。注意，圆形只是向量空间上度量的视觉效果，与无穷范数无关。

Proposition 4.1 贪婪诱导策略的直接误差边界 (Direct error bound of greedily induced policy)

给定一个无限范围MDP { X , U , p , g , γ } \{\mathcal{X}, \mathcal{U}, p, g, \gamma\} {X,U,p,g,γ}，让 $J^{\ast }$是最佳总成本函数，$J$是$J^{\ast }$的近似值，$\pi$是定义3.5中关于$J$的贪婪诱导策略。
$${\Vert J^{\pi }-J^{\ast }\Vert }_{\infty }\le \frac{2\gamma }{1-\gamma }{\Vert J-J^{\ast }\Vert }_{\infty }\text{\hspace{1em}(4.1)}$$

---

Proof.

由于策略$\pi$是关于$J$的贪婪诱导策略，很明显，${\mathrm{T}}_{\pi }J={\mathrm{T}}_{\mathfrak{g}}J$ 那么，我们可以简单地
$$\begin{array}{rl}{\Vert J^{\pi }-J^{\ast }\Vert }_{\infty }& ={\Vert J^{\pi }-{\mathrm{T}}_{\pi }J+{\mathrm{T}}_{\pi }J-J^{\ast }\Vert }_{\infty }\\ & \le {\Vert J^{\pi }-{\mathrm{T}}_{\pi }J\Vert }_{\infty }+{\Vert {\mathrm{T}}_{\pi }J-J^{\ast }\Vert }_{\infty }\\ & \le \gamma {\Vert J^{\pi }-J\Vert }_{\infty }+{\Vert {\mathrm{T}}_{\mathfrak{g}}J-{\mathrm{T}}_{\mathfrak{g}}{J}^{\ast }\Vert }_{\infty }\\ & \le \gamma {\Vert J^{\pi }-J\Vert }_{\infty }+\gamma {\Vert J-J^{\ast }\Vert }_{\infty }\end{array}\text{\hspace{1em}(4.2)}$$

其中，第一个不等式是根据无穷范数的三角不等式，而第二和第三个不等式是由于贝尔曼算子${\mathrm{T}}_{\pi }$和$T_{\mathfrak{g}}$的收缩性质。 同样，根据无穷范数的三角不等式，我们可以用以下结果代替公式$(4.2)$，
$${\Vert J^{\pi }-J\Vert }_{\infty }\le {\Vert J^{\pi }-J^{\ast }\Vert }_{\infty }+{\Vert J-J^{\ast }\Vert }_{\infty }\text{\hspace{1em}(4.3)}$$

并得出

$${\Vert J^{\pi }-J^{\ast }\Vert }_{\infty }\le \gamma {\Vert J^{\pi }-J^{\ast }\Vert }_{\infty }+2\gamma {\Vert J-J^{\ast }\Vert }_{\infty }\text{\hspace{1em}(4.4)}$$
即得结果。

---

Remark 4.1
在这里，很容易将该界限解释为直接的上界，即假定来自估计值$J$和地面真值$J^{\ast }$的初始误差，见图5中的可视化。将$\gamma$ 代入公式（4.1），如果$\gamma \le 1/3$，那么GIP的总成本函数的误差界限就保证小于或等于初始误差。如果$\gamma >1/3$,那么误差甚至可以被放大。换句话说，误差边界的问题取决于折扣系数的总成本。

地面真值$J^{\ast }$是一个正确的基准值，一般用来进行误差估算和效果评价。

此外，由于一般情况下，地面真值$J^{\ast }$并不是给定的，也就是说，初始误差$\Vert J-J^{\ast }{\Vert }_{\infty }$是不可用的，我们当然需要一些替代品。正如Lemma 3.4所建议的，初始误差也可以通过利用最优贝尔曼算子的一步应用的误差来估计。也就是，我们有以下的约束
$${\Vert J^{\pi }-J^{\ast }\Vert }_{\infty }\le \frac{2\gamma }{(1-\gamma {)}^2}{\Vert J-{\mathrm{T}}_{\mathfrak{g}}J\Vert }_{\infty }\text{\hspace{1em}(4.5)}$$

很简单，我们可以把它解释为一个间接上限。那么很明显，可以理解的是，这个间接上界是更宽松的约束。特别是，如果参数$\gamma$接近于1，间接界限就会变得非常宽松。在下文中，我们提出另一种方法来估计不同的间接约束。

Proposition 4.2 贪婪诱导策略的间接误差边界

给定一个无限范围 M D P { X , U , p , g , γ } M D P\{\mathcal{X}, \mathcal{U}, p, g, \gamma\} MDP{X,U,p,g,γ}，让$J^{\ast }\in {\mathbb{R}}^K$是最优的总成本函数，$J$是$J^{\ast }$的近似值，$\pi$是定义3.5中关于$J$的贪婪诱导策略。那么，贪婪诱导策略$J^{\ast }$的总成本函数$J^{\pi }$的上界为
$${\Vert J^{\pi }-J^{\ast }\Vert }_{\infty }\le \frac{2}{1-\gamma }{\Vert {\mathrm{T}}_{\mathfrak{g}}J-J\Vert }_{\infty }\text{\hspace{1em}(4.6)}$$

---

Proof.

首先，我们运用与Proposition $4.1$相同的技巧，得到
$$\begin{array}{rl}{\Vert J^{\pi }-J^{\ast }\Vert }_{\infty }& ={\Vert J^{\pi }-J+J-J^{\ast }\Vert }_{\infty }\\ & \le {\Vert J^{\pi }-J\Vert }_{\infty }+{\Vert J-J^{\ast }\Vert }_{\infty }\\ & \le {\Vert J^{\pi }-J\Vert }_{\infty }+\frac{1}{1-\gamma }{\Vert J-{\mathrm{T}}_{\mathrm{g}}J\Vert }_{\infty }\end{array}\text{\hspace{1em}(4.7)}$$

其中第二个不等式是由Lemma 3.4得出的。然后我们回顾$\pi$的构造为${\mathrm{T}}_{\pi }J={\mathrm{T}}_{\mathfrak{g}}J$，并进一步对公式(4.7)最后一个不等式的右边第一项进行同样的运算，即

$$\begin{array}{rl}{\Vert J^{\pi }-J\Vert }_{\infty }& ={\Vert J^{\pi }-{\mathrm{T}}_{\mathfrak{g}}J+{\mathrm{T}}_{\mathfrak{g}}J-J\Vert }_{\infty }\\ & \le {\Vert J^{\pi }-{\mathrm{T}}_{\mathfrak{g}}J\Vert }_{\infty }+{\Vert {\mathrm{T}}_{\mathfrak{g}}J-J\Vert }_{\infty }\\ & \le \gamma {\Vert J^{\pi }-J\Vert }_{\infty }+{\Vert {\mathrm{T}}_{\mathfrak{g}}J-J\Vert }_{\infty }\end{array}\text{\hspace{1em}(4.8)}$$

i.e.,

$${\Vert J^{\pi }-J\Vert }_{\infty }\le \frac{1}{1-\gamma }{\Vert {\mathrm{T}}_{\mathfrak{g}}J-J\Vert }_{\infty }\text{\hspace{1em}(4.9)}$$

将上述内容代入公式（4.7）中的不等式就可以得到结果。

---

显然，这两个间接误差界限是不同的，其比率取决于折扣系数$\gamma$。具体来说，如果$\gamma <0.5$，公式（4.5）中的间接界限比公式（4.6）中的更收紧，反之，如果$\gamma >0.5$，我们就得出贪婪诱导策略间接界限的结果。

Theorem 4.1 GIPs的间接约束 (Indirect bound of GIPs)

给定一个无限范围 M D P { X , U , p , q , γ } M D P\{\mathcal{X}, \mathcal{U}, p, q, \gamma\} MDP{X,U,p,q,γ}，让$J^{\ast }\in {\mathbb{R}}^K$为最优总成本函数，$J$为$J^{\ast }$的近似值，$\pi$为公式（3.5）中定义的相对于$J$贪婪诱导策略。那么，贪婪诱导策略$J^{\ast }$的总成本函数$J^{\pi }$的上界为

$${\Vert J^{\pi }-J^{\ast }\Vert }_{\infty }\le \min \left\{\frac{2\gamma }{(1-\gamma {)}^2},\frac{2}{1-\gamma }\right\}{\Vert {\mathrm{T}}_{\mathfrak{g}}J-J\Vert }_{\infty }\text{\hspace{1em}(4.10)}$$

Remark 4.2
根据最优贝尔曼算子的固定点性质，当且仅当近似总成本函数$J$确实是真正的最优总成本函数$J^{\ast }$时，公式（4.10）中不等式右边的项为零。因此，诱导贪婪策略似乎对错误非常敏感。另一方面，我们知道，通过问题的构造，只有有限的几个策略。Theorem 4.1中提出的GIP的误差界限可能过于保守。

4.2 策略空间中VI的收敛性 （Convergence of VI in policy space）

如Proposition 3.5贝尔曼算子的收缩性所示，$VI$算法收敛于最优总成本函数。那么很明显，关于总成本函数估计的无限序列的GIPs也收敛于最优策略。根据只有有限数量的策略的假设，可以合理地预期，在有限数量的$VI$迭代之后，当总成本函数的估计值足够接近于真正的最优总成本函数时，相关的GIPs会稳定在一个最优策略。

Proposition 4.3

给定一个无限范围$MDP$ { X . U , p , q , γ } \{\mathcal{X} . \mathcal{U}, p, q, \gamma\} {X.U,p,q,γ}，在最优总成本函数$J^{\ast }$周围存在一个开放的邻域，用$\mathcal{N}\left(J^{\ast }\right)$表示，这样，关于在$J\in \mathcal{N}\left(J^{\ast }\right)$中的任何$J$的$GIP$是最优的。

---

Proof
让我们用${\mathfrak{P}}_{dm}^{\ast }$来表示最优策略的集合。根据策略数量是有限的这一结构，以及贝尔曼算子的唯一固定点，很明显，最优总成本和任何非最优总成本之间有差距，也就是说，。

$$\rho :=\underset{\pi \notin {\mathfrak{P}}_{dm}^{\ast }}{\min }{\Vert J^{\pi }-J^{\ast }\Vert }_{\infty }>0\text{\hspace{1em}(4.11)}$$

构造上，Proposition 4.1意味着，对于任何任意的$J$，满足

$${\Vert J-J^{\ast }\Vert }_{\infty }<\frac{\rho (1-\gamma )}{2\gamma }\text{\hspace{1em}(4.12)}$$

相应的GIP ${\pi }_{\mathfrak{g}}(J)$关于$J$的总成本函数是在上界严格约束的，即
$${\Vert J_{{\pi }_{\mathfrak{g}}(J)}-J^{\ast }\Vert }_{\infty }\le \frac{2\gamma }{1-\gamma }{\Vert J-J^{\ast }\Vert }_{\infty }<\rho \text{\hspace{1em}(4.13)}$$

因此，一个GIP ${\pi }_{\mathfrak{g}}(J)$ 必须是最优的。

---

Proposition 4.4

给定一个无限范围 M D P { X , U , p , g , γ } M D P\{\mathcal{X}, \mathcal{U}, p, g, \gamma\} MDP{X,U,p,g,γ}，让$J_0\in {\mathbb{R}}^K$是一个任意的总成本函数估计值， { J k } k = 1 , 2 … . \left\{J_{k}\right\}_{k=1,2 \ldots .} {Jk​}k=1,2….​是VI算法（Algorithm 1）产生的序列，那么存在一个数 $\kappa \in \mathbb{N}$，这样对于所有$k\ge \kappa$，相关的$GIP{\pi }_k:={\pi }_{\mathfrak{g}}\left(J_k\right)$是最优。

---

Proof
让一个任意的$J_0$初始化VI算法（算法1），并通过以下方式定义原始误差

$$c_0:={\Vert J_0-J^{\ast }\Vert }_{\infty }\text{\hspace{1em}(4.14)}$$

最佳贝尔曼算子的收缩特性导致第k个总成本函数估计与最佳总成本函数的误差界限${\mathrm{T}}_{\mathrm{a}}^k{J}_0$如下
$${\Vert {\mathrm{T}}_{\mathfrak{g}}^k{J}_0-J^{\ast }\Vert }_{\infty }\le {\gamma }^k{c}_0<\frac{\rho (1-\gamma )}{2\gamma }\text{\hspace{1em}(4.15)}$$

其中第二个不等式来自Proposition 4.3. 如果

$$k>\left[{\log }_{\gamma }\frac{\rho (1-\gamma )}{2\gamma c_0}\right]\text{\hspace{1em}(4.16)}$$

直接得出所有 GIP 的${\pi }_k$是最佳的。

---

4.3 策略迭代算法 （The Policy Iteration Algorithm）

上一节的结果清楚地表明了$VI$在策略空间中的收敛性。然而，它的性能仍然在很大程度上取决于$VI$的性质。通过观察符合条件的策略空间是有限的这一事实，我们在下面的命题中研究了基于策略的真实总成本的最优贝尔曼算子的进一步性质。

Proposition 4 . 5 策略改进的性质 (Properties of Policy Improvement).

给定一个无限范围 M D P { X , U , p , g , γ } M D P\{\mathcal{X}, \mathcal{U}, p, g, \gamma\} MDP{X,U,p,g,γ},让$J^{\pi }\in {\mathbb{R}}^K$为任意固定策略$\pi$的总成本函数，${\pi }^{\prime }:={\pi }_{\mathfrak{g}}\left(J^{\pi }\right)$为公式（3.34）中定义的GIP。

即, ${\mathrm{T}}_{{\pi }^{\prime }}{J}^{\pi }={\mathrm{T}}_{\mathfrak{g}}{J}^{\pi }.$ 然后，我们有

$$J^{{\pi }^{\prime }}\le J^{\pi }\text{\hspace{1em}(4.17)}$$
并且，当且仅当$J^{\pi }$是最优总成本函数时，该等式成立。

---

Proof

根据贝尔曼算子${\mathrm{T}}_{\pi }$的固定点特性，即${\mathrm{T}}_{\pi }{J}^{\pi }=J^{\pi }$，以及最优Bellam算子的特性，即${\mathrm{T}}_{\mathfrak{g}}{J}^{\pi }\le {\mathrm{T}}_{\pi }{J}^{\pi }$，我们有

$${\mathrm{T}}_{\mathfrak{g}}{J}^{\pi }\le {\mathrm{T}}_{\pi }{J}^{\pi }=J^{\pi }\text{\hspace{1em}(4.18)}$$

GIP ${\pi }^{\prime }$ 的构建结果是

$${\mathrm{T}}_{{\pi }^{\prime }}{J}^{\pi }\le {\mathrm{T}}_{\mathfrak{g}}{J}^{\pi }\le J^{\pi }\text{\hspace{1em}(4.19)}$$

那么公式（4.17）中的结果直接来自于Corollary 3.2。

如果$J^{\pi }$等于最优总成本函数$J^{\ast }$，那么很容易就能看出平等性成立。如果$J^{{\pi }^{\prime }}=J^{\pi }$，那么公式（4.19）中的结果会导致

$$J^{{\pi }^{\prime }}={\mathrm{T}}_{\mathfrak{g}}{J}^{\pi }=J^{\pi }\text{\hspace{1em}(4.20)}$$

显然，根据${\mathrm{T}}_{\mathfrak{g}}$的唯一固定点特性，$J^{\pi }=J^{\ast }$。

---

计算策略$\pi$的真实总成本函数$J^{\pi }$的过程被称为策略评估 Policy
Evaluation (PE) ，或$RL$的预测任务。相关的贝尔曼算子$T_{\pi }$的固定点性质给出了一个简单的算法。最后，我们对$PI$算法的收敛性做出如下结论。

Theorem 4 . 2 PI的收敛性 (Convergence of PI )

给定一个无限范围 M D P { X , U , p , g , γ } M D P\{\mathcal{X}, \mathcal{U}, p, g, \gamma\} MDP{X,U,p,g,γ}，$PI$算法在有限多次扫描中收敛到最优总成本函数。

---

Proof

根据命题4.5，我们很容易看到 $J_{{\pi }_{k+1}}\le J_{{\pi }_k}$ 由于假设状态空间和行动空间都是有限的，所以静止策略的数量也是有限的。根据策略改进的严格改进特性，很明显PI算法在有限多次扫描中收敛。

---

现在很明显，PI算法的瓶颈是PE，即迭代策略评估需要无限次地迭代贝尔曼算子。在下文中，我们在MDP模型中引入了一个方便的解决方案。让我们回顾贝尔曼方程为

$$J^{\pi }(x)={\mathbb{E}}_{p_{\pi }\left(x^{\prime }\mid x\right)}\left[g\left(x,\pi (x),x^{\prime }\right)+\gamma J^{\pi }\left(x^{\prime }\right)\right]\text{\hspace{1em}(4.21)}$$

定义4.1预期成本函数 (Expected cost function)

给定一个无限范围MDP问题 { X , U , p , g , γ } \{\mathcal{X}, \mathcal{U}, p, g, \gamma\} {X,U,p,g,γ}，在状态$x\in \mathcal{X}$的预期成本函数被定义为

$$G_{\pi }(x):={\mathbb{E}}_{p_{\pi }\left(x^{\prime }\mid x\right)}\left[g\left(x,\pi (x),x^{\prime }\right)\right]\text{\hspace{1em}(4.22)}$$

我们进一步定义状态转换矩阵$P_{\pi }$为从每个状态$x$到其所有潜在后续状态$x^{\prime }$的转换概率。

$$P_{\pi }:=\left[\begin{array}{ccc}{p}_{11}& \cdots & p_{1K}\\ & \ddots & \\ p_{K1}& \cdots & p_{KK}\end{array}\right]\text{\hspace{1em}(4.23)}$$

其中$P_{\pi }$的每一行之和为1。矩阵$P_{\pi }$被称为Markov矩阵。下面的结果描述了Markov矩阵的特征值的有界性，这对进一步的发展很有帮助。

Lemma 4.1

给定一个马尔科夫矩阵 $P\in {\mathbb{R}}^{m\times m}$, 对于$i=1,\dots ,m$ 其特征值${\lambda }_i$ 满足$\left|{\lambda }_i\right|\le 1$

---

proof

让$\lambda \in \mathbb{C}$是$P$的一个特征值，$x\in {\mathbb{C}}^m$是一个相应的特征向量，即,$Mx=\lambda x.$ 让$k$为$x$中模数最大的条目的索引，即$\left|x_k\right|\ge \left|x_i\right|$ for all $i=1,\dots ,m$。那么我们有

$$\begin{array}{rl}\left|\lambda x_k\right|& =|\lambda |\cdot \left|x_k\right|\\ & =\left|\sum _{j=1}{p}_{kj}{x}_j\right|\\ & \le \sum _{j=1}{p}_{kj}\left|x_j\right|\\ & \le \sum _{j=1}{p}_{kj}\left|x_k\right|\\ & =\left|x_k\right|\end{array}\text{\hspace{1em}(4.24)}$$

因此这种关系$|\lambda |\cdot \left|x_k\right|\le \left|x_k\right|$ 导致 $|\lambda |\le 1$

---

那么贝尔曼方程可以表示为

$$J^{\pi }=G_{\pi }+\gamma P_{\pi }{J}^{\pi }\text{\hspace{1em}(4.25)}$$

其中$J^{\pi }\in {\mathbb{R}}^K$中，每个状态有一个对应的项，即

$$\left[\begin{array}{c}{J}^{\pi }\left(x_1\right)\\ ⋮\\ J^{\pi }\left(x_K\right)\end{array}\right]=\left[\begin{array}{c}{G}_1\\ ⋮\\ G_K\end{array}\right]+\gamma \left[\begin{array}{ccc}{p}_{11}& \cdots & p_{1K}\\ & \ddots & \\ p_{K1}& \cdots & p_{KK}\end{array}\right]\left[\begin{array}{c}{J}^{\pi }\left(x_1\right)\\ ⋮\\ J^{\pi }\left(x_K\right)\end{array}\right]\text{\hspace{1em}(4.26)}$$

通过求解$J_k\in {\mathbb{R}}^K$线性方程，可以很容易地找到解
$$\left(I_K-\gamma P_{\pi }\right)J=G_{\pi }\text{\hspace{1em}(4.27)}$$

由于$\gamma$的总成本严格小于1，Lemma 4.1意味着矩阵$I_K-\gamma P_{\pi }$是可逆的。因此，线性方程组有一个唯一的解，即
$$J={\left(I_K-\gamma P_{\pi }\right)}^{-1}{G}_{\pi }\text{\hspace{1em}(4.28)}$$

很明显，解决方案的近似形式表达只适用于MDP环境。让我们回顾一下公式（3.8）中定义的贝尔曼方程。除了固定点算法外，还有一个由寻根问题给出的替代解决方案。也就是说，我们定义
$$\begin{array}{rl}{F}_{\pi }:{\mathbb{R}}^K\to {\mathbb{R}}^K,J& \mapsto J-{\mathrm{T}}_{\pi }J\\ & =\left(I_K-\gamma P_{\pi }\right)J-G_{\pi }\end{array}\text{\hspace{1em}(4.29)}$$

显然，这是一个线性系统$F_{\pi }(J)=0$的寻根问题，其解在公式$(4.28)$中简单给出。

同样地，我们定义一个非线性算子

$$F_{\mathfrak{g}}:{\mathbb{R}}^K\to {\mathbb{R}}^K,J\mapsto J-{\mathrm{T}}_{\mathfrak{g}}J\text{\hspace{1em}(4.30)}$$

很容易看出，$F_{\mathfrak{g}}(J)=0$的解只是最佳总成本函数。解决非线性寻根问题的一个经典方案是牛顿法。不幸的是，最优的贝尔曼算子${\mathrm{T}}_{\mathfrak{g}}$在$J$中一般是不可微的。因此，采用牛顿方法的概念是不直接可行的。尽管如此，让$J_k$为根的第$k$个估计值，并假设存在一个唯一的策略${\pi }_k$，使得 ${\mathrm{T}}_{{\pi }_k}{J}_k={\mathrm{T}}_{\mathfrak{g}}{J}_k$换句话说，我们假设 $P_{{\pi }_k}$的存在。那么$F_{\mathfrak{g}}$的Jacobian可以计算为

$$J_{F_{\mathfrak{g}}}\left(J_k\right)=I_K-\gamma P_{{\pi }_k}\text{\hspace{1em}(4.31)}$$

因此，标准牛顿方法可以形成以下迭代更新规则
$$\begin{array}{rl}{J}_{k+1}& =J_k-{\left(I_K-\gamma P_{{\pi }_k}\right)}^{-1}{F}_{{\pi }_k}\left(J_k\right)\\ & =J_k-{\left(I_K-\gamma P_{{\pi }_k}\right)}^{-1}\left(\left(I_K-\gamma P_{{\pi }_k}\right)J_k-G_{{\pi }_k}\right)\\ & ={\left(I_K-\gamma P_{{\pi }_k}\right)}^{-1}{G}_{{\pi }_k}\end{array}\text{\hspace{1em}(4.32)}$$

这就是策略迭代算法。有了这样一个有趣的解释，部署潜在的数字方法确实是一个自然的步骤，这将在后面的章节中讨论。

4.4 优化策略迭代算法 (Optimistic Policy Iteration Algorithms)

VI算法的本质是解决一连串的优化问题。那么很明显，当状态空间巨大时，VI算法的计算成本会非常高。一个有趣的观察是，在VI算法的每一步都有一个合法的策略产生。通过这样的事实，评估一个正常的策略，即一个线性算子，通常比评估一个最优的贝尔曼算子要容易得多。多次执行这些GIP算子是很直观的，见Algorithm 3。众所周知，如果第五行的迭代次数$m_k$达到无穷大，那么多步策略评估就会收敛到某些不一定是最优策略的总成本函数，见图6 。这样的算法通常被称为优化策略迭代算法，也被称为修正策略迭代算法。在本节的其余部分，我们研究这种算法的收敛性。

图6：修改后的总成本迭代，又称优化策略迭代。从第$k$个 总成本函数估计值$J_k$开始，实线路径表示最优策略迭代的评估。而虚线表示总成本迭代的潜在评估。

---

我们首先研究多步策略迭代的特性。对于任意$m$步我们定义多步贝尔曼算子，即

$${\mathrm{T}}_{\pi }^m:{\mathbb{R}}^K\to {\mathbb{R}}^K,J\mapsto \underset{m\text{ times }}{\underbrace{\left({\mathrm{T}}_{\pi }\circ \dots \circ {\mathrm{T}}_{\pi }\right)}}J\text{\hspace{1em}(4.33)}$$

被称为$m$步贝尔曼算子。从命题3.6，可以直接得出以下结果。

Lemma 4.2

给定一个无限范围MDP $\mathcal{X},\mathcal{U},p,g,\gamma$，让$J,J^{\prime }\in {\mathbb{R}}^K$是总成本函数的两个估计值，那么$m$步贝尔曼算子是一个关于无穷范数的${\gamma }^m$-收缩映射，即,

$${\Vert {\mathrm{T}}_{\pi }^{m}J-{\mathrm{T}}_{\pi }^m{J}^{\prime }\Vert }_{\infty }\le {\gamma }^m{\Vert J-J^{\prime }\Vert }_{\infty }\text{\hspace{1em}(4.34)}$$

Proposition 4.6 特殊OPI的融合 (Convergence of Special OPI)

给定一个无限范围M D P { X , U , p , g , γ } \{\mathcal{X}, \mathcal{U}, p, g, \gamma\} {X,U,p,g,γ}。让$J_0$满足${\mathrm{T}}_{\mathfrak{g}}{J}_0\le J_0$，并且 { J k } \left\{J_{k}\right\} {Jk​}和 { π k } \left\{\pi_{k}\right\} {πk​}是由最优PI算法生成的序列，那么$J_k$在$k\to \infty$时收敛到$J^{\ast }$。 此外，对于所有指数$k$大于某个指数 $\kappa ，{\pi }_k$对于所有$k>\kappa$是最优的。

---

Proof.
根据策略改进的定义, 即, ${\mathrm{T}}_{{\pi }_0}{J}_0={\mathrm{T}}_{\mathfrak{g}}{J}_0$, 我们有

$${\mathrm{T}}_{{\pi }_0}{J}_0={\mathrm{T}}_{\mathfrak{g}}{J}_0\le J_0\text{\hspace{1em}(4.35)}$$

让我们假设 ${\mathrm{T}}_{{\pi }_k}{J}_k\le J_k$。然后我们有

$$\begin{array}{rlrl}{\mathrm{T}}_{{\pi }_{k+1}}{J}_{k+1}& ={\mathrm{T}}_{\mathfrak{g}}{J}_{k+1}& & \text{ (Policy improvement) }\\ & & & \\ & \le {\mathrm{T}}_{{\pi }_k}{J}_{k+1}& & \text{ (Optimal Bellman operator) }\\ & & & \\ & =\left({\mathrm{T}}_{{\pi }_k}\circ {\mathrm{T}}_{{\pi }_k}^{m_k}\right)J_k& & \text{ (Optimistic policy evaluation) }\\ & \le {\mathrm{T}}_{\pi k}^{m_k}{J}_k& & \text{ (Assumption + Lemma 3.2) }\\ & & & \\ & =J_{k+1}& & \text{ (Optimistic policy evaluation) }\end{array}\text{\hspace{1em}(4.36)}$$

因此，不等式${\mathrm{T}}_{{\pi }_k}{J}_k\le J_k$对OPI算法生成的所有$J_k$序列都成立。我们进一步推导出

$$\begin{array}{rl}{J}_k& ={\mathrm{T}}_{{\pi }_{k-1}}^{m_{k-1}}{J}_{k-1}\\ & \le {\mathrm{T}}_{{\pi }_{k-1}}{J}_{k-1}\\ & ={\mathrm{T}}_{\mathfrak{g}}{J}_{k-1}\end{array}\text{\hspace{1em}(4.37)}$$

其中不等式由推论3.2得出，第二个等式是策略改进步骤。很明显，我们有

$$J^{\ast }\le J_k\le T_{\mathfrak{g}}^k{J}_0\text{\hspace{1em}(4.38)}$$

让$k\to \infty$导致的结果是，$J_k$在极限时收敛到$J^{\ast }$。

最后，由于策略的有限性，可以得出存在一个常数$c>0$，这样如果$\Vert J-J^{\ast }\Vert \le c$和${\mathrm{T}}_{\pi }J={\mathrm{T}}_{\mathrm{g}}J$，那么$\pi$就会被收敛。那么$\pi$就是最优的。因此，显而易见的是

$$\begin{array}{rl}{\Vert J_k-J^{\ast }\Vert }_{\infty }& \le {\Vert {\mathrm{T}}_{\mathfrak{g}}^k{J}_0-J^{\ast }\Vert }_{\infty }\\ & \le {\gamma }^k{\Vert J_0-J^{\ast }\Vert }_{\infty }\\ & \le c\end{array}\text{\hspace{1em}(4.39)}$$

因此，可以直接得出结论：${\pi }_k$对于所有足够大的$k$来说都是最优的，证明结束。

---

Remark 4.3
尽管该命题证明了OPI算法在经过一定数量的扫描（sweep）后收敛于最优策略，但收敛性只能从总成本函数的角度来确定。最后一个结果如公式（4.39）所示，OPI在总成本函数的收敛方面与VI算法没有区别。换句话说，与经典的VI算法相比，选择OPI算法似乎没有什么好处。在本节的其余部分，我们研究OPI算法的收敛速度。

Proposition 4 . 7 优化PI的收敛性 (Convergence of Optimistic PI)

给定一个无限范围 M D P { X , U , p , g , γ } M D P\{\mathcal{X}, \mathcal{U}, p, g, \gamma\} MDP{X,U,p,g,γ}让 { J k } \left\{J_{k}\right\} {Jk​}和 { π k } \left\{\pi_{k}\right\} {πk​}是由最优$PI$算法产生的序列。那么$J_k$就会收敛到$J^{\ast }$。此外，对于所有指数$k$大于某个指数$\kappa$，${\pi }_k$对于所有$k>\kappa$都是最优的，并且

$${\Vert J_{k+1}-J^{\ast }\Vert }_{\infty }\le {\gamma }^m{\Vert J_k-J^{\ast }\Vert }_{\infty }\text{\hspace{1em}(4.40)}$$

---

Proof.

鉴于总成本函数$J_0$的初始估计，我们定义

$$c:={\Vert {\mathrm{T}}_{\mathfrak{g}}{J}_0-J_0\Vert }_{\infty }\text{\hspace{1em}(4.41)}$$

那么，对于所有$x\in \mathcal{X}$来说，有以下几点是明显的

$${\mathrm{T}}_{\mathfrak{g}}{J}_0(x)-J_0(x)\le c=\frac{c(1-\gamma )}{1-\gamma }\text{\hspace{1em}(4.42)}$$

这相当于

$${\mathrm{T}}_{\mathfrak{g}}{J}_0(x)+\frac{\gamma c}{1-\gamma }\le J_0(x)+\frac{c}{1-\gamma }\text{\hspace{1em}(4.43)}$$

显然，左手边是在右手边应用最优贝尔曼算子$T_{\mathfrak{g}}$的结果。也就是说，对于任何$J_0$，我们可以构建

$$J_0^{\prime }(x):=J_0(x)+\frac{c}{1-\gamma }\text{\hspace{1em}(4.44)}$$

对于所有 $x\in \mathcal{X}$，所以${\mathrm{T}}_n{J}_0^{\prime }\le J_0^{\prime }$ 需要注意的是，对$J_0$和$J_0^{\prime }$应用$OPI$算法的结果是对所有$k=0,\dots ,\infty$的相同策略序列${\pi }_k$。因此，在不丧失一般性的情况下，我们只需要研究应用于$J_0^{\prime }$的$OPI$的收敛特性。

根据最优贝尔曼算子${\mathrm{T}}_{\mathfrak{g}}$的单调性，我们有

$$\begin{array}{rl}\underset{k\to \infty }{\lim }\left(J_k^{\prime }(x)-J_k(x)\right)& =\underset{k\to \infty }{\lim }\frac{c{\gamma }^k}{1-\gamma }\\ & =0\end{array}\text{\hspace{1em}(4.45)}$$

对于所有$x\in \mathcal{X}$。

由于$J_k\to J^{\ast }$，因此，对于所有大于某个指数的$k$，${\pi }_{k+1}$是一个最优策略，所以${\mathrm{T}}_{{\pi }_{k+1}}={\mathrm{T}}_{\mathfrak{g}}$。因此，我们有

$$\begin{array}{rl}{\Vert J_{k+1}-J^{\ast }\Vert }_{\infty }& ={\Vert {\mathrm{T}}_{{\pi }_k}^m{J}_k-J^{\ast }\Vert }_{\infty }\\ & ={\Vert {\mathrm{T}}_{{\pi }_k}^m{J}_k-{\mathrm{T}}_{{\pi }_k}^m{J}^{\ast }\Vert }_{\infty }\\ & \le {\gamma }^m{\Vert J_k-J^{\ast }\Vert }_{\infty }\end{array}\text{\hspace{1em}(4.46)}$$

证明结束。

---

remark 4.4
如公式（4.46）所示的结果表明，在策略收敛到最优策略后，OPI算法产生的总成本函数收敛得更快。因此，OPI算法通常被认为是更有效的，因为它避免了密集解决一连串优化问题的沉重计算负担。

4.5 Policy Iteration: E-Bus

Consider a group of electric buses running round trips 24 hours a day. The task is to identify optimal operating actions at different battery states. The battery’s endurance and charging speed gradually decrease with the increase of battery life. Hence, for different buses, they have different transition probabilities between battery states. The following figure illustrates the state transitions between different states.

• Three states: H - high battery, L - low battery, E - empty battery
• Two actions: $\mathrm{S}$ - continue to serve, $\mathrm{C}$ - charge
• Numbers on the edges refer to transition probabilities. $\alpha =0.5,\beta =0.3,ϵ=0.7$
• Discount factor $\gamma =0.9$ .
  We choose the number of unserviced passengers as the local costs:
• In the high battery state, if it keeps the service, the unserviced passenger number is 0 .
• In the low battery stats, if it keeps the service, the unserviced passenger number is 2 . (We could imagine some of passengers might give up getting on the bus due to low battery status.)
• In the low battery state, if it charges the battery, the unserviced passenger number is 10 . (Since the charging time is relatively short.)
• In the empty battery state, if it charges the battery, the unserviced passenger number is 20 . (Since the charging time is longer.)
  Two eligible deterministic Markov policies are given as follows,

$${\pi }_1(x)=\{\begin{array}{ll}C,& \text{ if }x=E\\ S,& \text{ if }x=L\\ S,& \text{ if }x=H\end{array}$$

and

$${\pi }_2(x)=\{\begin{array}{ll}C,& \text{ if }x=E\\ C,& \text{ if }x=L\\ S,& \text{ if }x=H\end{array}$$

(hint: $J^{\ast }=[31.034,37.930,49.792{]}^{\top }$ )

(1) Error bound of GIP: Given $J_0=0$ , verify the correctness Eq. (4.10) in Theorem 4.1 (in the manuscript) numerically.
(2) Convergence of VI in policy space: Estimate the largest number of iterations that the VI needs to iterate, so that all GIPs afterwards are optimal.
(3) Closed-form PI algorithm: Starting from policy ${\pi }_1$ , compute one sweep of the closed-form PI algorithm.

import math
import numpy as np
from numpy.linalg import inv
import matplotlib.pyplot as plt


# some constants:
gamma = 0.9
alpha = 0.5
beta = 0.3
epsilon = 0.7

# local costs:
gec = 20  # g(E,C)=20
ghs = 0  # g(H,S)=0
glc = 10  # g(L,C)=10
gls = 2  # g(L,S)=2

print("\n---------- Policy Iteration (closed form) ----------\n")

# Init total cost:
jh = jl = je = 0  # J(H)=J(L)=J(E)=0
ul = 0  # initial policy: pi_1: H->S, E->C, L->S
print("Init policy: pi_1: H->S, E->C, L->S")


# closed form definition, based on definition 4.1
# expected cost function G for pi_1
G_pi_1 = np.array([
    alpha * ghs + (1-alpha) * ghs,
    beta * gls + (1-beta) * gls,
    epsilon * gec + (1-epsilon) * gec
])

# state transition matrix P for pi_1
P_pi_1 = np.array([
    [alpha, 1-alpha, 0],
    [0, beta, 1-beta],
    [epsilon, 1-epsilon,0 ]
])

# expected cost function G for pi_2
G_pi_2 = np.array([
    alpha * ghs + (1-alpha) * ghs,
    glc,
    epsilon * gec + (1-epsilon) * gec
])

# state transition matrix P for pi_2
P_pi_2 = np.array([
    [alpha, 1-alpha, 0],
    [1, 0, 0],
    [epsilon, 1-epsilon, 0]
])

for k in range(0, 4):
    # Policy evaluation: compute J^{pi_k}
    if ul == 0:
        J_pi = np.dot(inv(np.identity(3) - gamma * P_pi_1), G_pi_1)  # based on Eq. 4.28
        jh, jl, je = float(J_pi[0]), float(J_pi[1]), float(J_pi[2])
    else:
        J_pi = np.dot(inv(np.identity(3) - gamma * P_pi_2), G_pi_2)  # based on Eq. 4.28
        jh, jl, je = float(J_pi[0]), float(J_pi[1]), float(J_pi[2])

    # Policy improvement by GIP
    ul = np.argmin([
        beta * (gls + gamma * jl) + (1 - beta) * (gls + gamma * je),  # Service
        glc + gamma * jh  # Charge
    ])

    if ul == 0:
        print("Iter {} \t pi_1: H->S, E->C, L->S".format(k))
    elif ul == 1:
        print("Iter {} \t pi_2: H->S, E->C, L->C".format(k))

print('After PI, jh = {}, jl = {}, je = {}\n'.format(jh, jl, je))

print("\n---------- Optimistic Policy Iteration ----------\n")

def T_pi(jh, jl, je, ul):
    je_ = epsilon * (gec + gamma * jh) + (1-epsilon) * (gec + gamma * jl)
    jh_ = alpha * (ghs + gamma * jh) + (1-alpha) * (ghs + gamma * jl)
    if ul == 0:
        jl_ = beta * (gls + gamma * jl) + (1-beta) * (gls + gamma * je)
    elif ul == 1:
        jl_ = glc + gamma * jh

    return jh_, jl_, je_

# Init total cost:
jh = jl = je = 0  # J(H)=J(L)=J(E)=0

for k in range(0, 4):
    # Policy improvement: generate a GIP
    ul = np.argmin([
        beta * (gls + gamma * jl) + (1-beta) * (gls + gamma * je),  # Service
        glc + gamma * jh  # Charge
    ])
    if ul == 0:
        print("Iter {} \t pi_1: H->S, E->C, L->S".format(k))
    elif ul == 1:
        print("Iter {} \t pi_2: H->S, E->C, L->C".format(k))

    # Finite-step Policy Evaluation: compute J_k+1 by evaluating T_pi on J_k
    m_k = 0
    j_threshold = 1
    while j_threshold > 0.001:
        jh_, jl_, je_ = T_pi(jh, jl, je, ul)
        j_threshold = max(abs(jh_-jh), abs(jl_-jl), abs(je_-je))
        jh, jl, je = jh_, jl_, je_
        m_k += 1
    print('\t after PE:jh = {:.4f}, jl = {:.4f}, je = {:.4f}'.format(jh, jl, je))
    print("\t {} steps for policy evaluation\n".format(m_k))

print('After OPI, jh = {}, jl = {}, je = {}\n'.format(jh, jl, je))

the outputs are

---------- Policy Iteration (closed form) ----------

Init policy: pi_1: H->S, E->C, L->S
Iter 0 	 pi_2: H->S, E->C, L->C
Iter 1 	 pi_2: H->S, E->C, L->C
Iter 2 	 pi_2: H->S, E->C, L->C
Iter 3 	 pi_2: H->S, E->C, L->C
After PI, jh = 31.034482758620683, jl = 37.93103448275862, je = 49.793103448275865


---------- Optimistic Policy Iteration ----------

Iter 0 	 pi_1: H->S, E->C, L->S
	 after PE:jh = 50.7878, jl = 62.0759, je = 68.7559
	 84 steps for policy evaluation

Iter 1 	 pi_2: H->S, E->C, L->C
	 after PE:jh = 31.0432, jl = 37.9398, je = 49.8018
	 74 steps for policy evaluation

Iter 2 	 pi_2: H->S, E->C, L->C
	 after PE:jh = 31.0423, jl = 37.9389, je = 49.8010
	 1 steps for policy evaluation

Iter 3 	 pi_2: H->S, E->C, L->C
	 after PE:jh = 31.0415, jl = 37.9381, je = 49.8002
	 1 steps for policy evaluation

After OPI, jh = 31.041547850465356, jl = 37.938099574603285, je = 49.80016854012053