• 参考：
  • 周博磊老师的教程
  • 强化学习（三）用动态规划（DP）求解
• 本节主要讨论已知MDP情况下的两个核心问题：预测(prediction)和控制(control)
• 我们用MDP对RL中的环境进行建模，所谓 “model-based”，就是指Agent已知环境的变化情况，或者说Agent对环境进行了 “全观测”（full observability）。这种情况下我们已知环境MDP的转移矩阵P和奖励函数R，往往使用动态规划（DP）的方法进行求解
• 符号说明：本文用 $S_t$ 或 s 代表当前时刻 t 的状态，$S_{t+1}$ 或 s’ 代表下一时刻的状态；$A_t$ 或 a 代表当前时刻 t 的动作，$A_{t+1}$ 或 a’ 代表下一时刻的动作

1. prediction（policy evaluation）

1.1 问题描述

• 预测问题又叫策略评估，其实就是计算MDP中的价值函数$V^{\pi }$
• 形式化描述：
  • 输入：MDP $<S,A,P,R,\gamma >$ 及 Policy $\pi$ 或 MRP $<S,P^{\pi },R^{\pi },\gamma >$
  • 输出：价值函数$V^{\pi }$(s)

1.2 解法

1.2.1 思想：同步反向迭代

• 直接使用MDP的Bellman公式
  $$V^{\pi }(s)=\sum _{a\in A}\pi (a|s)[R(s,a)+\gamma \sum _{s^{\prime }\in S}P(s^{\prime }|s,a)V^{\pi }(s^{\prime })]$$
  反复迭代计算至收敛即可
• Policy $\pi$ 是在从状态$s$到$s^{\prime }$中加入的一个动作概率分布，在policy evaluation中这个Policy是已经给定的分布，因此它不重要。把Policy隐藏到计算过程中，有
  $$\begin{gathered} P^{\pi }(s^{\prime }|s)=\sum _{a\in A}\pi (a|s)P(s^{\prime }|s,a) \\ {R}^{\pi }(s)=\sum _{a\in A}\pi (a|s)R(s,a) \end{gathered}$$
  于是MDP $<S,A,P,R,\gamma >$ 转化为 MRP $<S,P^{\pi },R^{\pi },\gamma >$，故用
  $$V(s)=R^{\pi }(S)+\gamma \sum _{s^{\prime }\in S}{P}^{\pi }(s^{\prime }|s)V(s^{\prime })$$
  反复迭代计算至收敛也可以进行policy evaluation

1.2.2 伪代码

1. 初始化所有$s\in S$ 的 V(s) = 0
2. while循环，在每一步利用状态s的下一步的所有可能状态s’更新$V(s)，s\in S$ ，如下
   $$V_{t+1}^{\pi }(s)=\sum _{a\in A}\pi (a|s)[R(s,a)+\gamma \sum _{s^{\prime }\in S}P(s^{\prime }|s,a)V_t^{\pi }(s^{\prime })]$$
3. 当$V_{t+1}^{\pi }(s)$ 和 $V_t^{\pi }(s)$ 的差值小于 $ϵ$ 时，认为$V^{\pi }(s)$ 已经收敛。停止迭代，policy evaluation完成。

1.2.3 收敛性证明

• policy evaluation本质就是利用Bellman公式计算 $V^{\pi }(s)$，可以使用不动点法，利用Bellman算子$B_{\pi }$ 把解$V^{\pi }(s)$ 等价转换为找 $B_{\pi }$的不动点。
• 可以证明$B_{\pi }$是单调的，再利用压缩映射定理，可以证明任何值函数 $V^{\pi }$ 都有 $\underset{x\to \infty }{\lim }{B}_{\pi }^N{V}^{\pi }=V^{\pi }$，这保证了我们可以从一个随机的起点出发，不断按照Bellman方程更新从而收敛到 $V^{\pi }$。因此伪代码第一步V(s)的初始值可以任意设置。
• 详细证明过程见：用Bellman算子理解动态规划

1.2.4 和动态规划的关系

• 这个同步反向迭代算法同时满足 “无后效性” 和 “重复子问题”

  1. Bellman等式给出了递归分解公式，和$V^{\pi }(s)$相关的状态仅有其下一个状态的$V^{\pi }(s^{\prime })$，而和历史状态无关。满足无后效性
  2. 价值方程$V^{\pi }(s)$ 是个重复子问题，可以记录重用
  3. 虽然这个问题中没有最优子结构，但是这也不是一个最优化问题，只要找到子问题的解即可。

• 因此，policy evaluation可以用动态规划解决，上面这个伪代码本质就是递推形式的动态规划算法，从这个角度考虑，我们具体操作时可以设置一个dp数组，存储每一轮迭代时$V^{\pi }(s)$的值

1.3 示例

1.3.1 经典方格世界

• 本示例转载自：强化学习（三）用动态规划（DP）求解
• 这是一个经典的Grid World的例子。我们有一个4x4的16宫格。只有左上和右下的格子是终止格子。该位置的价值固定为0，个体如果到达了该2个格子，则停止移动，此后每轮奖励都是0。
• 个体在16宫格其他格的每次移动，得到的即时奖励R都是-1。
• 个体每次只能移动一个格子，且只能上下左右4种移动选择，不能斜着走, 如果在边界格往外走，则会直接移动回到之前的边界格。
• 衰减因子 γ=1，即不考虑衰减
• 给定的策略是随机策略，即每个格子里有25%的概率向周围的4个格子移动
  
• 说明：
  
• 根据上面的分析，这个带数字的方格就可以看做动态规划形式中的二维数组dp

1.3.2 变形方格世界

• 这是上面经典Grid World例子的变形，来自斯坦福公开课：Grid World
• 依然是一个方格地图，其中灰色的部分和地图边界都是墙壁（详见下面的截图），如果顶着墙壁走，会停留在原地
• 左上角格子是初始状态，中间R=1的格子是终态。到达终态时除了获得R=1的奖励，还会被立即传送到起点
• 个体每次移动，不得到奖励。每个方格是一个state，奖励函数R(s)已经在地图中标注出来，在进入（离开）方格时会得到左下角标注的奖励
• 个体每次只能移动一个格子，且只能上下左右4种移动选择，不能斜着走
• 衰减因子 γ=0.9
• 给定的策略是随机策略，即每个格子里有25%的概率向周围的4个格子移动
• 分析

  1. 首先把地图所有V(s)初始化为0
     

  2. 由于所有$V_0(s)=0$，则$V_1(s)=R(s)$
     

  3. 继续迭代，只关注中间部分
     
     看这里绿色格正上方-1.23的格，根据MRP形式的Bellman公式：$-1.23=-1+0.9\ast 0.25\ast (-1+(-1)+1+0)$，这里括号中的-1/-1/1/0 分别来自第2步中此格右边/自身/下面/上面的这几个状态s’的$V_t^{\pi }(s^{\prime })$，它们是从此格（状态）出发的所有下一步可能格（状态）

  4. 继续执行这个迭代直到收敛（$V_t^{\pi }(s)$几乎不变），这样就得到了所有状态的价值，policy evaluation完成
     

1.4 示例代码

• 这是上面变形方格世界在策略评估部分的核心代码，是作者用javaScript编写的

  // 执行一轮Policy evaluation（同步迭代）
  evaluatePolicy: function() {
        
        
  	  // 初始化所有v(s) = 0,然后遍历更新
  	  var Vnew = zeros(this.ns); 				
  	  for(var s=0;s < this.ns;s++) {
        
        			
  		    var v = 0.0;
  		    var poss = this.env.allowedActions(s);			// poss是当前状态可能执行的动作集合
  		    // 遍历所有可能动作进行价值求和
  		    for(var i=0,n=poss.length;i < n;i++) {
        
        
  			      var a = poss[i];								// 选取的动作
  			      var prob = this.P[a*this.ns+s]; 				// probability of taking action under current policy
  			      var ns = this.env.nextStateDistribution(s,a); // look up the next state
  			      var rs = this.env.reward(s,a,ns); 			// get reward for s->a->ns transition（立即奖励 R(s,a)）
  			      v += prob * (rs + this.gamma * this.V[ns]);	// 这个this.V数组可以看作动态规划中的dp数组
  	    	}
  	    	Vnew[s] = v;
  	  }
  	  this.V = Vnew; // 更新价值函数
  }
  

  可以看到这里只执行了bellman公式中的第一个求和（对所有可能动作的求和），这是因为此示例中每个<s,a>只对应一个新状态s‘，即$P(s^{\prime }|s,a)=1$，因此后面的求和没有必要了，直接把新状态的V(s)拿来就可以了。另外作者还对当前状态下采取各个动作的概率prob 做了一个压缩存储，用一维数组代替了二维数组，详见下面的作者的解释
• Here, we see this.ns (number of states), this.P which stores the current policy, and this.env, which is a pointer to the Environment object. The policy array is one-dimensional in this implementation, but stores the probability of taking any action in any state, so I’m using funny indexing (this.P[a*this.ns+s]) to not have to deal with 2D arrays in Javascript. The code implements the synchronous Value backup for each state:
  $$V_{t+1}^{\pi }(s)=\sum _{a\in A}\pi (a|s)[R(s,a)+\gamma \sum _{s^{\prime }\in S}P(s^{\prime }|s,a)V_t^{\pi }(s^{\prime })]$$
  However, note that in the code we only took expectation over the policy actions (the first sum above), while the second sum above was not evaluated because this Gridworld is deterministic (i.e. ns in the code is just a single integer indicating the next state). Hence, the entire probability mass is on a single next state and no expectation is needed.

2. Control（search the optimal policy）

2.1 问题描述

• 控制问题又叫找最优策略，其实就是找到一个最优策略$\pi$，使得每个状态的价值$V^{\pi }(s)$最大
• 形式化描述：
  • 输入：MDP $<S,A,P,R,\gamma >$
  • 输出：最佳价值函数$V^{\ast }(s)=\underset{\pi }{\max }{V}^{\pi }(s)$ 以及 最佳策略${\pi }^{\ast }(s)=\underset{\pi }{\mathrm{argmax}}{V}^{\pi }(s)$

2.2 分析

• 如果一个MDP的最佳价值函数$V^{\ast }(s)$被求出，则称这个MDP已经被解了（solved）
• 一个MDP只存在一个特殊的$V^{\ast }(s)$，但可能有多个最佳策略 ${\pi }^{\ast }$可以到达它
• 在一个无穷horizon的MDP问题中，最佳策略 ${\pi }^{\ast }$有以下特点
  1. Deterministic（确定性的）： ${\pi }^{\ast }$ 一定存在
  2. Stationary（稳定的）：${\pi }^{\ast }$ 不随时间变化
  3. not unique（不唯一）
• 对于每个状态s，找${\pi }^{\ast }(a|s)$可以转换为找最优动作价值函数$q^{\pi }(s,a)$
  
  也就是说：如果在状态s下动作a使得(s,a)的长期奖励最大，则这个动作a必为最佳动作，最佳策略应该是以1的概率选择这个动作的策略。即${\pi }^{\ast }(a|s)=P(a|s)=1$。
• 若已知$q^{\ast }(s,a)$，就可以立即得到${\pi }^{\ast }(s)=a$，也能立刻得到$V^{\ast }(s)=q^{\ast }(s,{\pi }^{\ast }(s))=q^{\ast }(s,a)$。
• 因此解MDP control只要搜索$q^{\ast }(s,a)$就可以了，由于a和s都是有限集，可以使用穷举法，但这样效率太低了

2.3 解法

2.3.1 Policy iteration算法

2.3.1.1 思想

• 反复迭代执行以下两步，直到V收敛为止

  1. policy evaluation（就是本文第一部分那个）：给定当前的$\pi$，计算价值函数$V$（这一步需要多次迭代至收敛）
  2. policy improve：对$V^{\pi }$采取贪心算法，从而提升policy：${\pi }^{\prime }=greedy(\pi )$

• 图示
  

2.3.1.2 策略提升（policy improve）

• 通过最大化q函数来实现策略提升，这
• 分成两步
  1. 根据$\pi$计算$q$
     
  2. 对于每个s，贪心地找到使$q^{{\pi }_i}(s,a)$最大的a来更新 $\pi (s)$
     
     

2.3.1.3 策略改进定理

1. 策略改进定理：如果$\pi$和${\pi }^{\prime }$是任意两个 确定策略（Deterministic policy，对于每个s选择一个确定的a），对任意状态$s\in S$，若有
   $$q_{\pi }(s,{\pi }^{\prime }(s))\ge v_{\pi }(s)$$
   则称策略${\pi }^{\prime }$相比$\pi$一样好或更好，即对任意状态s，肯定能取得一样好或更好的期望回报，即
   $$v_{{\pi }^{\prime }}(s)\ge v_{\pi }(s)$$
   且若第一个式子严格不等，第二个式子也严格不等
2. 证明策略改进定理
   
3. 推广：对于随机策略（Stochastic policy，对于每个s，给出对应a的概率分布并采样一个a），策略改进定理也成立

2.3.1.4 收敛性证明

• 我们在Policy improve阶段遍历了所有可能的action，通过贪心保证了新选中的a一定是目前状态s下的最优选择，这样就可以利用策略改进定理保证Policy的性能必然是单调不减的，即V(s)单调不减。
  

• 又因为衰减系数$\gamma \in [0,1]$的存在，V(s)通常存在一个上限，根据单调有界定理，Policy iteration算法必能收敛到最优解

2.3.1.5 Bellman最优等式

• 当Policy iteration算法收敛后，有
  
  这个式子就是说：通过遍历找最优action得到的下一轮策略 ${\pi }^{\prime }$ 在状态s下选择动作的return评估，已经和本轮策略 $\pi$ 在状态s下选择动作的return评估相等了。这意味着在状态s下，Policy已经不能找出性能更好的动作，策略$\pi$即成为最优策略${\pi }^{\ast }$。

• 注意，找到最优策略 ${\pi }^{\ast }$ 时，每个状态s对应的a仍可能不唯一，只是被限制在一个或几个最优动作中，它们的动作状态价值$q^{\ast }(s,a)=q^{\ast }(s,{\pi }^{\ast }(s))$都是最大的。根据上面的分析，此时可以立刻得最优价值函数$V^{\ast }(s)$

• 于是我们获得了Bellman最优等式（Bellman optimality equation），即达到最优时，有
  $$V^{\ast }(s)=\underset{a\in A}{\max }{q}^{\ast }(s,a)$$
  我个人认为这里的max可以省略，因为上标* (${\pi }^{\ast }$) 可以保证$q^{\ast }(s,a)$中的a一定满足max条件，下面涉及到max符号的地方也同理

• 同样的，我们还可以把Bellman最优等式反着写，即
  

• 把上面两个互相带入，可得相邻时刻$V^{\ast }(s)$的关系和相邻时刻$q^{\ast }(s,a)$的关系

  $$\begin{gathered} V^{\ast }(s)=\underset{a}{\max }(R(s,a)+\gamma \sum _{s^{\prime }\in S}P(s^{\prime }|s,a)V^{\pi }(s^{\prime })) \\ {q}^{\ast }(s,a)=R(s,a)+\gamma \sum _{s^{\prime }\in S}P(s^{\prime }|s,a)\underset{a^{\prime }}{\max }{q}^{\ast }(s^{\prime },a^{\prime }) \end{gathered}$$

2.3.1.6 示例代码

• 这段还是来自斯坦福公开课的变型方格世界例子：Grid World，这里提供了一个交互式可视化Policy iteration算法演示

  1. 多次点击Policy evaluation使各个状态的V(s)收敛，完成策略评估
  2. 点击一次Policy update，执行策略提升

• 也可以直接点击Toggle policy evaluation自动执行这个算法

• 现在关注策略提升的核心代码

  // update policy to be greedy w.r.t. learned Value function
  updatePolicy: function() {
        
        
   	// iterate over all states...
   	for(var s=0;s < this.ns;s++) {
        
        
     	   	var poss = this.env.allowedActions(s);	// 动作集
  	   	// compute value of taking each allowed action
  	   	var vmax;		// v(s)最大值
  	   	var nmax;		// 使v(s)最大的动作个数
  	   	var vs = [];	// 存储每个可能动作使v(s)达到的值
  	   	for(var i=0,n=poss.length;i < n;i++) {
        
        
  		     var a = poss[i];
  		     // compute the value of taking action a
  		     var ns = this.env.nextStateDistribution(s,a);	// 下一步状态
  		     var rs = this.env.reward(s,a,ns);				// 即刻奖励
  		     var v = rs + this.gamma * this.V[ns];			// 当前状态的v(s)
  		     // bookeeping: store it and maintain max
  		     vs.push(v);
  		     if(i === 0 || v > vmax) {
        
         vmax = v; nmax = 1; }
  		     else if(v === vmax) {
        
         nmax += 1; }
  	   	}
  	   	// update policy smoothly across all argmaxy actions
  	   	for(var i=0,n=poss.length;i < n;i++) {
        
        
  		     var a = poss[i];
  		     this.P[a*this.ns+s] = (vs[i] === vmax) ? 1.0/nmax : 0.0;	// pi(a|s)为能使v(s)到达vmax的动作之一（概率均分）
  	   }
   	}
  }
  

  可以看到，和上面的policy evaluation一样，方格世界这个例子的特殊性又产生了作用，由于<s,a>直接决定s’，有
  $$V^{{\pi }_i}(s)=q^{{\pi }_i}(s,a)=R(s,a)+V^{{\pi }_i}(s^{\prime })$$
  因此policy improvement阶段可以通过贪心$V^{{\pi }_i}(s)$来实现。说明这一点后上面的代码应该很容易看懂了

2.3.2 Value iteration算法

2.3.2.1 思想

• 直接看上面从Bellman最优等式得到这个式子
  $$V^{\ast }(s)=\underset{a}{\max }(R(s,a)+\gamma \sum _{s^{\prime }\in S}P(s^{\prime }|s,a)V^{\ast }(s^{\prime }))$$
• 类似policy evaluation，直接反复迭代这个式子至收敛即可

2.3.2.2 收敛性证明

• 这个证明和Policy evaluation中的证明极其相似，详见：用Bellman算子理解动态规划

2.3.2.3 伪代码

• 代码
  
• 说明：
  1. 初始化V(s)的值可以随机设
  2. 第二步的循环的终止条件是$V(s)$收敛，此时得$V^{\ast }(s)$
  3. 为了得到${\pi }^{\ast }$，先用$V^{\ast }(s)$构造$q^{\ast }(s,a)$，再通过$\underset{a}{\mathrm{argmax}}$得到 ${\pi }^{\ast }$

2.3.2.4 和动态规划的关系

• 这个迭代过程满足动态规划的三大要求：“无后效性”、“重复子问题”、“最优子结构”

  1. Bellman optimality等式给出了递归分解公式，可以看出和$V^{\ast }(s)$相关的状态仅有其下一个状态的$V^{\ast }(s^{\prime })$，而和历史状态无关。满足无后效性
  2. 价值方程$V^{\ast }(s)$ 是个重复子问题，可以记录重用
  3. 解$V^{\ast }(s)$可以转换为解子问题$V^{\ast }(s^{\prime })$，满足最优子结构

• 因此适合用递推形式动态规划的写法完成这个迭代算法

2.4 对比两种方法

• 首先我们有一个贪心策略，可以通过最大化 $q(s,a)$ 找到状态s下的最优策略 $\pi (s)$。
• 我们的核心目标在于不断提升$V(s)$使其收敛，两种算法只是从不同的角度实现这个提升
  1. Policy iteration：它每次迭代有比较明显的两个步骤，即策略评估和策略提升。每轮通过策略评估的结果v找出q，再最大化q找出更好的policy，从而在下一轮得到更好的v。所以我们是通过优化Policy来提升V，最终找到 $V^{\ast }$ 和 ${\pi }^{\ast }$
  2. Value iteration：我们直接利用$V^{\ast }$的递归关系进行迭代计算，从而绕过Policy直接提升了V，等V收敛到$V^{\ast }$后再通过最大化q找出${\pi }^{\ast }$

3. 总结和深入

3.1 已知MDP情况下prediction和control问题的小结

• 问题 - 算法表格
  

3.1.1 解prediction问题 —— policy evaluation

• 使用MDP的Bellman公式
  
  反复迭代计算至收敛

3.1.2 解control问题 —— policy iteration

• 反复迭代执行以下两步

  1. policy evaluation：迭代计算Bellman公式至收敛
     

  2. policy improve：根据$\pi$计算$q$，再对每个s贪心地找到使$q^{{\pi }_i}(s,a)$最大的a来更新 $\pi (s)$
     
     直到V收敛为止

3.1.3 解control问题 —— value iteration

• 使用MDP的Bellman optimal公式反复迭代计算至收敛，求出$V^{\ast }$
  

• 利用$V^{\ast }$重构$q^{\ast }$，从而对每个s贪心地找出动作a，得${\pi }^{\ast }$
  

3.2 改进上述问题中的动态规划算法

• 同步动态规划的一个主要缺点是，它们涉及对MDP整个状态集的操作，每轮迭代我们会计算出所有的状态价值并保存起来，在下一轮中，使用这些保存起来的状态价值来计算新一轮的状态价值。
• 如果状态集非常大，完整的状态集扫描复杂度太高，无法接受
• 可以使用异步动态规划算法进行改进，在这些算法里，每一次迭代并不对所有状态的价值进行更新，而是依据一定的原则有选择性的更新部分状态的价值，这类算法有自己的一些独特优势，当然有额会有一些额外的代价
• 下面介绍三种异步动态规划算法

3.2.1 原位动态规划 (in-place dynamic programming)

• 此时我们不会另外保存一份上一轮计算出的状态价值。而是即时计算即时更新。这样可以减少保存的状态价值的数量，节约内存。代价是收敛速度可能稍慢。
• 伪代码对比一下，其实很简单，就是个编程技巧
  
• 要注意的是两者并不完全等价，原位动态规划中，一轮for循环中靠后的部分可能用到更新过的v(s)，但由于收敛性，这个不会影响结果

3.2.2 优先级动态规划 (prioritised sweeping)

• 该算法对每一个状态进行优先级分级，优先级越高的状态其状态价值优先得到更新。
• 通常使用贝尔曼误差来评估状态的优先级，贝尔曼误差即新状态价值与前次计算得到的状态价值差的绝对值。贝尔曼误差大的优先级高
  
• 每次迭代后也要更新贝尔曼误差
• 这样可以加快收敛速度，代价是需要维护一个优先级队列

3.2.3 实时动态规划 (real-time dynamic programming)

• 实时动态规划直接使用个体与环境交互产生的实际经历来更新状态价值，对于那些个体实际经历过的状态进行价值更新。这样个体经常访问过的状态将得到较高频次的价值更新，而与个体关系不密切、个体较少访问到的状态其价值得到更新的机会就较少。收敛速度可能稍慢。