强化学习笔记（4）—— 有模型（model-based）prediction 和 control问题（DP方法）

• 参考：
  1. 周博磊老师的教程
  2. 强化学习（三）用动态规划（DP）求解
• 本节主要讨论已知MDP情况下的两个核心任务：预测(prediction)和控制(control)，他们对应到强化学习面对的两个根本性问题
  
  1. 预测任务 prediction：如何根据策略 $\pi$ 的奖励估计价值 $V^{\pi },Q^{\pi }$

     prediction 对应到 贡献度分配 这个 RL 根本问题：观察到 agent 某条轨迹得到了收益，想要分析轨迹中哪些动作对于这个收益贡献比较大。引入价值函数就是为了解决这个问题，状态价值函数$V^{\pi }$ 描述 “进入某状态” 的贡献大小；状态动作价值函数 $Q^{\pi }$ 描述 “在某状态执行某动作” 的贡献大小

  2. 控制任务 control：如何根据价值得到最优策略

     control 对应到 探索利用困境 这个 RL 根本问题：我们要利用当前评估预测出的价值函数找出最大化 agent 收益的策略，但这个价值又是随着 agent 不断与环境交互而渐进准确的，得到的策略需要在探索新状态和利用旧价值之间取得平衡。此问题详见 强化学习笔记（1）—— 概括与基础 1.5 节

• 我们用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’ 代表下一时刻的动作；$V,Q$ 代表所有 $s$ 或 $(s,a)$ 的价值数组；$v(s),q(s,a)$ 代表某个 $s$ 或 $(s,a)$ 的价值

---

1. prediction

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

1.1 Policy Evaluation 算法

1.1.1 思想：同步反向迭代

• 直接使用 MDP 的 Bellman 公式
  $$\begin{array}{rlr}{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 })]& (三参数式)\\ & =\sum _a\pi (a|s)\sum _{s^{\prime },r}p(s^{\prime },r|s,a)[r+\gamma v^{\pi }(s^{\prime })]& (四参数式)\end{array}$$ 反复迭代计算至收敛即可

  注：这里的三参数式和四参数式是 Bellman 公式的两种表示法，本文会混合使用，详见 强化学习笔记（3）—— 有限马尔可夫决策过程（finite MDP）

• 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.1.2 伪代码

1.1.3 收敛性证明

• policy evaluation本质就是利用Bellman公式计算 $V^{\pi }$，可以使用不动点法，利用Bellman算子$B_{\pi }$ 把解 $V^{\pi }$ 等价转换为找 $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.1.4 和动态规划的关系

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

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

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

1.2 示例

1.2.1 经典方格世界

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

1.2.2 变形方格世界

• 这是上面经典Grid World例子的变形，来自斯坦福公开课：Grid World
  1. 依然是一个方格地图，其中灰色的部分和地图边界都是墙壁（详见下面的截图），如果顶着墙壁走，会停留在原地
  2. 左上角格子是初始状态，中间R=1的格子是终态。到达终态时除了获得R=1的奖励，还会被立即传送到起点
  3. 个体每次移动，不得到奖励。每个方格是一个state，奖励函数R(s)已经在地图中标注出来，在进入（离开）方格时会得到左下角标注的奖励
  4. 个体每次只能移动一个格子，且只能上下左右4种移动选择，不能斜着走
  5. 衰减因子 $\gamma =0.9$
  6. 给定的策略是随机策略，即每个格子里有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 }$几乎不变），这样就得到了所有状态的价值，policy evaluation完成
     

1.3 示例代码

• 这是上面变形方格世界在策略评估部分的核心代码，是作者用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）

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

2.1 分析

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

2.2 Policy iteration算法

2.2.1 思想

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

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

• 图示
  

• 策略提升（policy improve）是通过最大化 $Q$ 函数来实现的，这分成两步

  1. 第 $i$ 轮迭代，根据当前策略 ${\pi }_i$ 计算 $q$
     
  2. 对于每个 $s$，贪心地找到使 $q^{{\pi }_i}(s,a)$ 最大的 $a$ 来更新 $\pi (s)$
     
     

2.2.2 伪代码

• 伪代码
  
• 这里假设 $\pi$ 是一个确定性策略，即 $\pi (s)$ 对应到某个确切的动作 $a$，而非关于 $a$ 的分布。若要其扩展为更加普适的随机性策略，需要做两点改变
  1. 在做 Policy Evaluation 时，像上面第一节一样使用随机性策略对应的 bellman 更新公式 $$v_{\pi }(s)=\sum _a\pi (a|s)\sum _{s^{\prime },r}p(s^{\prime },r|s,a)[r+\gamma v_{\pi }(s^{\prime })]$$
  2. 在做 Policy Improve中 $\underset{a}{\mathrm{argmax}}$ 操作时，可能有多个动作 $a$ 都对应到最大值，把 $\pi (s)$ 设置为这些动作的某个分布（只要所有其他动作被选中的总概率为 0 即可）
• 还有一个小问题，这里 Policy Improve 的停止条件使用动作是否变化来判断，在默认使用确定性策略的情况下，若有多个动作同样好，这里的 $\pi (s)$ 可能会不断变化导致算法无法终止，可以把收敛条件改成看所有状态总价值是否稳定

2.2.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. 现在考察我们上面的 Policy Improve 操作，对于确定性策略有
   $$\begin{array}{rl}{\pi }^{\prime }(s)& \doteq \underset{a}{\mathrm{argmax}}{q}_{\pi }(s,a)\\ & =\underset{a}{\mathrm{argmax}}\mathbb{E}[R_{t+1}+\gamma v_{\pi }(S_{t+1})|S_t=s,A_t=a]\\ & =\underset{a}{\mathrm{argmax}}\sum _{s^{\prime },r}p(s^{\prime },r|s,a)[r+\gamma v_{\pi }(s^{\prime })]\end{array}$$ 显然这里 $q_{\pi }(s,{\pi }^{\prime }(s))\ge v_{\pi }(s)$，因此满足策略改进定理，新的策略 ${\pi }^{\prime }$ 一定不差于 $\pi$

   当使用随机性策略时（所有非最优动作被选中的总概率为 0）这一定理也成立

2.2.4 收敛性证明

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

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

• 在收敛时有
  
  这个式子是说：通过遍历找最优action得到的下一轮策略 ${\pi }^{\prime }$ 在状态s下选择动作的return评估，已经和本轮策略 $\pi$ 在状态s下选择动作的return评估相等了

  1. 从直观意义上看，这意味着在状态 s 下，Policy已经不能找出性能更好的动作
  2. 从公式上看，这时 Bellman optimal equation $v^{\ast }(s)=\underset{a\in A}{\max }{q}^{\ast }(s,a)$ 成立

  这一切都说明此时策略 $\pi$ 已成为最优策略 ${\pi }^{\ast }$

  注意，找到最优策略 ${\pi }^{\ast }$ 时，每个状态s对应的a仍可能不唯一，只是被限制在一个或几个最优动作中，它们的动作状态价值都是最大的。

2.2.5 示例代码

• 这段还是来自斯坦福公开课的变型方格世界例子：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 Value Iteration算法

2.3.1 思想

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

2.3.2 伪代码

• 伪代码
  
• 注意
  1. 初始化 $V$ 的值可以随机设
  2. 循环的终止条件是 $V$ 收敛，此时得 $V^{\ast }$
  3. 为了得到 ${\pi }^{\ast }$，先用 $V^{\ast }$ 构造 $Q^{\ast }$，再通过 $\underset{a}{\mathrm{argmax}}$ 得到 ${\pi }^{\ast }$
  4. 这里的伪代码也是默认了确定性策略，可以像 2.2.2 节那样将其扩展为随机性策略

2.3.3 收敛性证明

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

2.3.4 和动态规划的关系

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

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

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

2.3.5 深入理解 Value Iteration

• 理解1：Value Iteration 是 一种特殊的 Policy Iteration，其中 Policy Evaluation 步骤在每轮迭代中仅执行一遍，即

  1. 利用 Bellman equation 更新一次
     $$\begin{array}{rl}{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 })]\\ & ={\mathbb{E}}_{\pi }[R(s,a)+\gamma \sum _{s^{\prime }\in S}P(s^{\prime }|s,a)v_{\pi }(s^{\prime })|s,a]\\ & =\sum _a\pi (a|s)\sum _{s^{\prime },r}p(s^{\prime },r|s,a)[r+\gamma v_{\pi }(s^{\prime })]\end{array}$$
  2. 执行 Policy Improve
     $${\pi }^{\prime }(s)=\underset{a}{\mathrm{argmax}}{q}_{\pi }(s,a)=\underset{a}{\mathrm{argmax}}\sum _{s^{\prime },r}P(s^{\prime },r|s,a)[r+\gamma v_{\pi }(s^{\prime })]$$

  从总体上看，第 $k$ 轮迭代时执行如下操作
  $$\begin{array}{rl}{v}_{k+1}(s)& =\underset{a}{\max }{\mathbb{E}}_{s^{\prime }\sim \text{env}}[R(s,a)+\gamma v_k(s^{\prime })|s,a]\\ & =\underset{a}{\max }\sum _{s^{\prime },r}p(s^{\prime },r|s,a)[r+\gamma v_k(s^{\prime })]\end{array}$$

• 理解2：Value Iteration 是 对贪心策略做 policy evaluation。我们知道，policy evaluation 使用 bellman equation 作为价值更新规则，而 Value Iteration 只是把更新规则改成了 bellman optimal equation

  1. bellman equation（policy evaluation）：$v_{\pi }(s)={\sum }_a\pi (a|s){\sum }_{s^{\prime },r}p(s^{\prime },r|s,a)[r+\gamma v_{\pi }(s^{\prime })]$
  2. bellman optimal equation（value Iteration）：$v_{\ast }(s)={\max }_a{\sum }_{s^{\prime },r}p(s^{\prime },r|s,a)[r+\gamma v_{\ast }(s^{\prime })]$

  区别仅在与更新时的策略不同，一个是评估策略 $\pi$，一个是贪心策略 ${\pi }^{\ast }$，进而价值收敛到了相应的策略

  要注意的是，value Iteration 迭代时贪心策略 ${\pi }^{\ast }$ 是不稳定的；policy evaluation 迭代时策略 $\pi$ 是稳定的
  另外 value Iteration 最后还通过构造并最大化 $Q^{\ast }$ 找出了 ${\pi }^{\ast }$

3. 总结和深入

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

• 问题 - 算法表格
  

3.1.1 解prediction问题 —— Policy Evaluation

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

3.1.2 解control问题 —— Policy Iteration

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

  1. Policy Evaluation：迭代计算 Bellman 公式至收敛
     

  2. Policy Improve：根据 $\pi$ 计算所有 $q(s,a)$，再对每个 $s$ 贪心地找到使 $q^{{\pi }_i}(s,a)$ 最大的 $a$ 来更新 $\pi (s)$
     

3.1.3 解control问题 —— Value Iteration

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

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

3.2 广义策略迭代（GPI）

• 我们注意到 Value Iteration 其实就是一个特殊的 Policy Iteration，它修改了其中 policy evaluation 步骤的粒度。事实上，Policy Iteration 中两个步骤的粒度并不影响算法收敛，因此我们可以将其推广到一个解control问题的更一般形式

• 先看 policy iteration，这个算法包括两个相互作用的流程

  1. 策略评估 policy evaluation：使得价值函数 $V$ 和当前策略 $\pi$ 匹配
  2. 策略提升 policy improve：根据当前价值贪心地更新策略 $\pi$

  policy iteration中这两个流程交替进行，每个流程都在另一个开始前完成。但这不是必须的，可以在两次策略提升之间只进行一次策略评估而不是一直迭代到收敛；在一些异步DP方法中，评估和改进以更细的粒度交替进行（比如可能某次评估中只有一个状态的价值进行了更新）。但是不管怎么样，只要两个流程持续更新所有状态，最后的结果都是相同的

• 我们定义广义策略迭代 (GPI)：指代让策略评估和策略提升交替进行相互改进的一般思路，不限制这两个流程的粒度和其他细节。几乎所有的RL方法都可以被描述为GPI，即几乎所有方法都包含明确定义的策略和价值函数。如下所示
  
  策略总是基于特定的价值函数进行改进，价值函数也始终会向相应的真实价值函数收敛。显然，当评估流程和改进流程都稳定下来不在变化时，价值函数和策略函数必定是最优的。当稳定到最优 $V^{\ast }$ 和 ${\pi }^{\ast }$ 时，价值函数一定和当前策略一致；策略一定对当前价值函数是贪心策略。因此，只有当一个策略发现它对自己的评估价值函数是贪心策略时，两个流程才能稳定下来，这意味着Bellman Optimal等式成立，这个策略和价值函数一定是最优的

• 可以将GPI的流程看成竞争与合作。虽然两个流程朝着相反的反向前进（让策略对价值函数贪心通常会使价值函数与当前策略不不匹配；使价值函数与策略一致通常会使策略不再贪心），但从长远看，这两个流程会相互作用以找到一个联合解决方案：最优价值 $V^{\ast }$ 和最优策略 ${\pi }^{\ast }$
  
  可以把每个流程看成二维空间中的一条线，代表对于其目标的解决方案。每个流程都把$V$或$\pi$推向其中一条线，由于这两条线不是正交的，所以两个目标间会产生相互作用。直接冲向某个目标会导致某种程度上偏离另一个目标，然而整体流程的结果最终会更接近最优的总目标。在GPI中，我们也可以让每次走的步子小一点，部分地实现其中一个目标。无论是哪种情况，尽管没有直接优化总目标，但策略评估和策略提升两个流程结合在一起，就可以最终达到最优的总目标

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

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

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

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

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

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

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

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