2、强化学习--动态规划

策略评价模型

问题：评价一个已知的策略$\pi$
解决方法：通过反向迭代贝尔曼期望方程
计算过程如下：
$$v_1\to v_2\to \dots \to v_{\pi }$$
使用的算法是：同步的反向传递(synchronous backup)

对于MRP过程可以写成这样：

注：动态规划的性质是，如果全局是最优的，那每个子问题都是最优的，反正不成立。e.g. 对于最短路问题而言，从1到10的最短路径，那么从9到10的所有可能的路径中的最短路一定是在1到10的最短路径中的。所以s’是s的后继状态，是一个从后向前的过程，backup由此而来。

下面来看一个4*4的方格世界的例子，来感受值函数的迭代过程：

已知：
状态空间S：如图。S1 - S14非终止状态，ST终止状态，下图灰色方格所示两个位置；
行为空间A：{n, e, s, w} 对于任何非终止状态可以有东南西北移动四个行为；
转移概率P：任何试图离开方格世界的动作其位置将不会发生改变，其余条件下将100%地转移到动作指向的状态；
即时奖励R：任何在非终止状态间的转移得到的即时奖励均为-1，进入终止状态即时奖励为0；
衰减系数γ：1；
当前策略π：Agent采用随机行动策略，在任何一个非终止状态下有均等的几率采取任一移动方向这个行为，即π(n|•) = π(e|•) = π(s|•) = π(w|•) = 1/4。
问题：评估在这个方格世界里给定的策略。
该问题等同于：求解该方格世界在给定策略(随机游走)下的（状态）价值函数，也就是求解在给定策略下，该方格世界里每一个状态的价值。
具体迭代过程见下图所示：

这里要注意：在四周的时候，例如在k=2的(1,0)位置，此处的值函数是-1.7，计算的时候是规定它可以向左走的，只不过它向左走之后仍旧会停留在原地，此时它所用的值函数是上一时刻该位置的值函数，并且也会因为一次转移而得到-1的reward。
具体演示的代码如下：

states = [i for i in range(16)]
values = [0  for _ in range(16)]
actions = ["n", "e", "s", "w"]

#动作对状态的改变，n就是向上走，位置-4，e向右，位置+1，以此类推。
ds_actions = {"n": -4, "e": 1, "s": 4, "w": -1}
gamma = 1.00

def nextState(s, a):
  next_state = s

  #这个if里写的是原地不动的情况
  if (s%4 == 0 and a == "w") or (s<4 and a == "n") or \
     ((s+1)%4 == 0 and a == "e") or (s > 11 and a == "s"):
    pass
  else:
    ds = ds_actions[a]
    next_state = s + ds
  return next_state

def rewardOf(s):
  return 0 if s in [0,15] else -1

#查看状态是否为终止态
def isTerminateState(s):
  return s in [0,15]

#获取某一状态的可能后继状态
def getSuccessors(s):
  successors = []
  if isTerminateState(s):
    return successors
  for a in actions:
    next_state = nextState(s, a)
    successors.append(next_state)
  return successors

#根据后继状态更新值函数
def updateValue(s):
  sucessors = getSuccessors(s)
  newValue = 0  # values[s]
  num = 4
  reward = rewardOf(s)
  for next_state in sucessors:
    newValue += 1.00/num * (reward + gamma * values[next_state])
  return newValue

#方便输出
def printValue(v):
  for i in range(16):
    print('{0:>6.2f}'.format(v[i]),end = " ")
    if (i+1)%4 == 0:
      print("")
  print()

#进行一次迭代
def performOneIteration():
  newValues = [0 for _ in range(16)]
  for s in states:
    newValues[s] = updateValue(s)
  global values
  values = newValues
  printValue(values)


max_iterate_times = 160
cur_iterate_times = 0
while cur_iterate_times <= max_iterate_times:
    print("Iterate No.{0}".format(cur_iterate_times))
    performOneIteration()
    cur_iterate_times += 1
printValue(values)

策略迭代

通过方格世界的例子，我们得到了一个优化策略的办法，分为两步：首先我们在一个给定的策略下迭代更新价值函数：
$$v_{\pi }(s)=\mathbb{E}\left[R_{t+1}+\gamma R_{t+2}+\dots |S_t=s\right]$$
随后，在当前策略基础上，贪婪地选取行为，使得后继状态价值增加最多：
$${\pi }^{\prime }=\mathrm{greedy}\left(v_{\pi }\right)$$
通过上述过程一定能收敛到最优策略，因为MDP一定存在最优策略。

在当前策略上迭代计算v值，再根据v值贪婪地更新策略，如此反复多次，最终得到最优策略${\pi }^{\ast }$和最优状态价值函数$V^{\ast }$。

注：收敛率不受初始策略和初始值函数的影响。

关于策略迭代一定能提升表现的证明

1.考虑一个确定性的策略(其他策略也是一个意思，毕竟只要看出值函数有提升即可)：$a=\pi (s)$
2.我们通过贪心来更新一步
$${\pi }^{\prime }(s)=\underset{a\in \mathcal{A}}{\mathrm{argmax}}{q}_{\pi }(s,a)$$
可以得到以下式子：
$$q_{\pi }\left(s,{\pi }^{\prime }(s)\right)=\underset{a\in \mathcal{A}}{\max }{q}_{\pi }(s,a)\ge q_{\pi }(s,\pi (s))=v_{\pi }(s)$$
注意式子里面的下标，比较细节。
因此我们可以有如下递推式：
$$\begin{array}{rl}{Q}^{\pi }(s,{\pi }^{\prime }(s))& =E[r_{t+1}+V^{\pi }(s_{t+1})|s_t=s,a_t={\pi }^{\prime }(s_t)]\\ & <=E[r_{t+1}+Q^{\pi }(s_{t+1},{\pi }^{\prime }(s_{t+1}))|s_t=s,a_t={\pi }^{\prime }(s_t)]\\ & =E[r_{t+1}+r_{t+2}+V^{\pi }(s_{t+2})|....]\\ & <=E[r_{t+1}+r_{t+2}+Q^{\pi }(s_{t+2},{\pi }^{\prime }(s_{t+2}))|....]\\ & ......\\ & <=V^{{\pi }^{\prime }}(s)\end{array}$$
很多时候，策略的更新较早就收敛至最优策略，而状态价值的收敛要慢很多，是否有必要一定要迭代计算直到状态价值得到收敛呢？有时候不需要持续迭代至最有价值函数，可以设置一些条件提前终止迭代，比如设定一个Ɛ，比较两次迭代的价值函数平方差；直接设置迭代次数；以及每迭代一次更新一次策略等。

价值迭代

优化原则 Principle of Optimality
一个最优策略可以被分解为两部分：从状态s到下一个状态s’采取了最优行为 $A_{\ast }$；在状态s’时遵循一个最优策略。
定理：一个策略能够使得状态s获得最优价值，当且仅当：对于从状态s可以到达的任何状态s’，该策略能够使得状态s’的价值是最优价值：

确定性的价值迭代

如果我们知道了子问题的最优价值函数$v_{\ast }(s^{\prime })$那么$v_{\ast }(s)$的最优值函数可以通过以下式子来得到：
$$v_{\ast }(s)\leftarrow \underset{a\in \mathcal{A}}{\max }{\mathcal{R}}_s^a+\gamma \sum _{s^{\prime }\in \mathcal{S}}{\mathcal{P}}_{s{s}^{\prime }}^a{v}_{\ast }\left(s^{\prime }\right)$$
在前一个定理的基础上，如果我们清楚地知道我们期望的最终（goal）状态的位置以及反推需要明确的状态间关系，那么可以认为是一个确定性的价值迭代。此时，我们可以把问题分解成一些列的子问题，从最终目标状态开始分析，逐渐往回推，直至推至所有状态。

价值迭代的过程

问题：找到最优的policy
解决方法：通过不断反向迭代贝尔曼最优方程
产生的中间步骤为：
$$v_1\to v_2\to \dots \to v_{\ast }$$
使用如下算法：

其最终会收敛到最优值函数(通过压缩映射来证明。)

价值迭代与策略迭代的区别

1. 前者迭代采用的是贝尔曼最优方程，后者是贝尔曼期望方程。
2. 值迭代并没有涉及到具体的policy，并且迭代的中间过程的值函数的并不对应于某一个policy，直到值函数收敛才有。而策略迭代则是根据策略不断改进值函数，这一值函数是明确对应着一个policy的，通过值函数改进策略不断循环（本文前面写的策略评价模型，和策略迭代不一样！）。

总结

该图很好地展示了策略评价，策略迭代，价值迭代之间的区别和联系。

• 预测问题：在给定策略下迭代计算价值函数。控制问题：策略迭代寻找最优策略问题则先在给定或随机策略下计算状态价值函数，根据状态函数贪婪更新策略，多次反复找到最优策略；单纯使用价值迭代，全程没有策略参与也可以获得最优策略，但需要知道状态转移矩阵，即状态s在行为a后到达的所有后续状态及概率。
• 使用状态价值函数或行为价值函数两种价值迭代的算法时间复杂度都较大 。一种改进方案是使用异步动态规划，其他的方法即放弃使用动态规划，随后的几讲中将详细讲解其他方法。

策略迭代的收敛性证明

首先定义两个值函数向量的无穷范数：
$$\Vert u-v{\Vert }_{\infty }=\underset{s\in \mathcal{S}}{\max }|u(s)-v(s)|$$
然后定义贝尔曼期望方程的向后运算符(backup operator)$T^{\pi }(v)$：
$$T^{\pi }(v)={\mathcal{R}}^{\pi }+\gamma {\mathcal{P}}^{\pi }v$$
这一运算符是一个$\gamma -$压缩。证明如下：
$$\begin{array}{rl}{\Vert T^{\pi }(u)-T^{\pi }(v)\Vert }_{\infty }& ={\Vert \left({\mathcal{R}}^{\pi }+\gamma {\mathcal{P}}^{\pi }u\right)-\left({\mathcal{R}}^{\pi }+\gamma {\mathcal{P}}^{\pi }v\right)\Vert }_{\infty }\\ & ={\Vert \gamma {\mathcal{P}}^{\pi }(u-v)\Vert }_{\infty }\\ & \le \gamma \Vert u-v{\Vert }_{\infty }\end{array}$$

引入压缩映射的相关数学知识：

观察我们的式子，发现其满足压缩映射原理的条件。故其满足以下定理：

含义是值函数一定会收敛到不动点，并且收敛速率=$\gamma$

这篇比我的证明要全一些：
https://zhuanlan.zhihu.com/p/68407730

价值迭代的收敛性证明

其实只要把贝尔曼期望方程换成贝尔曼最优方程即可：
重新定义backup operator $T^{\ast }$：
$$T^{\ast }(v)=\underset{a\in \mathcal{A}}{\max }{\mathcal{R}}^a+\gamma {\mathcal{P}}^{a}v$$
其也满足如下性质，证明和上面几乎一样：
$${\Vert T^{\ast }(u)-T^{\ast }(v)\Vert }_{\infty }\le \gamma \Vert u-v{\Vert }_{\infty }$$