【强化学习的数学原理】课程笔记--4（随机近似与随机梯度下降，时序差分方法）

系列笔记：
【强化学习的数学原理】课程笔记–1（基本概念，贝尔曼公式）
【强化学习的数学原理】课程笔记–2（贝尔曼最优公式，值迭代与策略迭代）
【强化学习的数学原理】课程笔记–3（蒙特卡洛方法）

随机近似与随机梯度下降

这个部分主要是为了下一章 时序差分方法 做铺垫，其内容也适用于机器学习等方向。

Mean estimation

上一节 中我们已经讨论过，在 model-free 的情况下，为了求解
$$q_{{\pi }_k}(s,a)=E[G_t|S_t=s,A_t=a]$$
我们需要利用 大数定律 的结论，通过大量的采样 $g_{{\pi }_k}^{(i)}(s,a),i=1,2,\mathrm{3...}$，来估计 $q_{{\pi }_k}(s,a)$：
$$q_{{\pi }_k}(s,a)=\frac{1}{n}\sum _{i=1}^n{g}_{{\pi }_k}^{(i)}(s,a)$$

我们将上述问题简记为：
$$E(X)\approx \bar{x}=\frac{1}{n}\sum _{i=1}^n{x}_i$$

上述式子在实际中有一个效率的问题：需要等到所有的样本 $x_i$ 全都采集完毕才能计算。而上述式子有一个 等价 的迭代式子：
$$w_{k+1}=w_k-\frac{1}{k}(w_k-x_k)$$
其中 $w_k=\frac{1}{k-1}{\sum }_{i=1}^{k-1}{x}_i$ 。证明也很容易：
$$w_{k+1}=\frac{1}{k}\sum _{i=1}^k{x}_i=\frac{1}{k}(\sum _{i=1}^{k-1}{x}_i+x_k)=\frac{1}{k}((k-1)w_k+x_k)=w_k-\frac{1}{k}(w_k-x_k)$$

作为上式的延展，我们提出一个更广泛使用的迭代式：
$$w_{k+1}=w_k-{\alpha }_k(w_k-x_k)$$

在下面的 Robbins-Monro 算法 中，我们会展示：在满足一定条件时，上式依然满足 ${\lim }_{k\to \infty }{w}_k=E[X]$

---

Robbins-Monro 算法

Robbins-Monro 算法提出了以下框架：

要求解 $$g(w)=0$$
如果不知道 $g$ 的具体形式，但可以拿到足够多的采样 $g(w_k),k=1,2,\mathrm{3...}$，那么可以用迭代式：
$$w_{k+1}=w_k-a_k(g(w_k)+{\eta }_k),a_k>0$$
来求解，其中随机变量 $\eta \in \mathbb{R}$ 是观测误差。当以下条件满足时，可以保证 $w_k$ 收敛到 $w^{\ast }$ （$w^{\ast }$ 满足 $g(w^{\ast })=0$）：
\quad

1. $0<c_1\le {\nabla }_{w}g(w)\le c_2，\forall w$
   \quad
2. ${\sum }_{k=1}^{\infty }{a}_k=\infty$ 并且 ${\sum }_{k=1}^{\infty }{a}_k^2<\infty$
   \quad
3. $E[{\eta }_k|{\mathcal{H}}_k]=0$ 并且 $E[{\eta }_k^2|{\mathcal{H}}_k]<\infty$，其中 H k = { w k , w k − 1 , . . . } \mathcal{H}_k = \{w_k, w_{k-1}, ...\} Hk​={wk​,wk−1​,...}

下面我们依次来直观理解一下每个条件：

1. $0<c_1\le {\nabla }_{w}g(w)\le c_2，\forall w$：前半部分 $0<c_1\le {\nabla }_{w}g(w)$ 是要求 $g(w)$ 是单调递增函数，而由于常用的场景是求解 ${\min }_{w}J(w)$ 时，转化为求解 $${\nabla }_{w}J(w)=0$$，因此 $0<c_1\le {\nabla }_w^{2}J(w)\le c_2$ 即要求 $J(w)$ 是 凸函数。而后半部分 ${\nabla }_{w}g(w)\le c_2$ 则限制了 $g(w)$ 的增长率不会发散，否则会影响 $w_k$ 的收敛性。
   \quad
   \quad
2. ${\sum }_{k=1}^{\infty }{a}_k=\infty$ 并且 ${\sum }_{k=1}^{\infty }{a}_k^2<\infty$：这其实是希望 $a_k$ 是一个趋于 0，但又不会过快趋于 0 的序列。要求 $a_k$ 趋于 0 很好理解，因为 $$w_{k+1}-w_k=a_k(g(w_k)+{\eta }_k)$$ 因此 $a_k$ 趋于 0 才能保证 $w_k$ 能收敛。那 $a_k$ 不会过快趋于 0 有什么作用呢？由于 $$w_{k+1}-w_k=-a_k(g(w_k)+{\eta }_k)$$，因此 $$w_1-w_{\infty }=\sum _{k=1}^{\infty }{a}_k(g(w_k)+{\eta }_k)$$，如果 $a_k$ 很快就趋于 0 了，由于 ${\nabla }_{w}g(w)\le c_2$ ，因此 ${\sum }_{k=1}^{\infty }{a}_k(g(w_k)+{\eta }_k)$ 有上界，即 $$|w_1-w_{\infty }|\le b$$ 由此带来的问题是 $w_1$ 不能任意选择，因为若选的 $w_1$ 离 $w^{\ast }$ 太远，那么 $|w_1-w_{\infty }|\le b$ 就不成立了，因而是否能收敛到 $w^{\ast }$ 也无法保证 （NOTE：$a_k=\frac{1}{k}$ 就是一个满足条件的例子）
   \quad
   \quad
3. $E[{\eta }_k|{\mathcal{H}}_k]=0$ 并且 $E[{\eta }_k^2|{\mathcal{H}}_k]<\infty$：这个条件比较弱，甚至不要求 $\eta$ 满足高斯分布，只要 { η k } \{\eta_k\} {ηk​} 独立同分布，且满足 $E[{\eta }_k]=0，E[{\eta }_k^2]<\infty$ 即可。本质是希望 $\eta$ 中不要包含有效信息，有效的信息应该都包含在 $g(w)$ 中。

抛开上述条件，Robbins-Monro 算法的想法也很简单，就是：对于一个单调递增函数，随便取一个点 $w_1$，如果 $g(w_1)+{\eta }_1<0$，说明 $w^{\ast }$ 在$w_1$的右边，那么下一步应该往右走，而 $$w_2=w_1-a_1(g(w_1)+{\eta }_1)$$
由于 $g(w_1)+{\eta }_1<0$，因此 $-a_1(g(w_1)+{\eta }_1)>0$，即方向向右。同理，如果 $g(w_1)+{\eta }_1>0$，则下一步会往左走一点

图示：

用 Robbins-Monro 算法解释 Mean estimation

为了能将 Mean estimation 囊括到 Robbins-Monro 的框架下，我们需要定义：$$g(w)=w-E[X]$$
这样求解 $g(w^{\ast })=0$ 就等价于求解 $w^{\ast }=E[X]$。由此 Robbins-Monro 中的迭代式 $$w_{k+1}=w_k-a_k(g(w_k)+{\eta }_k)$$
其中 $g(w_k)=w_k-E[X]$，${\eta }_k$ 是样本 $x_k$ 的观测误差 $E[X]-x_k$（易证 $E[{\eta }_k]=0$ 且 $E[{\eta }_k^2]<\infty$），再取 $a_k=\frac{1}{k}$，因此有
$$\begin{array}{rl}{w}_{k+1}& =w_k-a_k(g(w_k)+{\eta }_k)\\ & =w_k-\frac{1}{k}(w_k-E[X]+E[X]-x_k)\\ & =w_k-\frac{1}{k}(w_k-x_k)\end{array}$$
即 Mean estimation

---

用 Robbins-Monro 算法解释 Batch Gradient descent

机器学习中常用的 Gradient descent 算法描述如下：
$$\underset{w}{\min }J(w)=E[f(w,X)]$$
其中 $f$ 即损失函数，$w$ 是模型中的待优化参数。求解的迭代式是：
$$\begin{array}{rl}{w}_{k+1}=& w_k-{\alpha }_k{\nabla }_{w}J(w)\\ =& w_k-{\alpha }_{k}E[{\nabla }_{w}f(w_k,X)]\\ =& w_k-{\alpha }_k\cdot \frac{1}{n}\sum _{i=1}^n{\nabla }_{w}f(w_k,x_i)\end{array}$$

其中 $(x_i,f(w_k,x_i))$ 即一对样本。由于每次更新 $w$ 都需要将所有的样本都计算到，因此也叫 Batch Gradient descent。 但跟 Mean estimation 类似，Batch Gradient descent 要求所有样本采样完毕才能计算，效率比较低。因此提出了每次只使用一个样本来更新参数的算法：Stochastic Gradient Descent （SGD）
$$w_{k+1}=w_k-{\alpha }_k{\nabla }_{w}f(w_k,x_k)$$

为了将 SGD 囊括到Robbins-Monro 的框架下，只需要定义 $$g(w)={\nabla }_{w}J(w)$$
那么求解 $g(w^{\ast })={\nabla }_{w}J(w^{\ast })=0$ 就等价于求解 ${\min }_{w}J(w)$ （当 $J(w)$ 是凸函数时），可以推导：
$$\begin{array}{rl}{w}_{k+1}=& w_k-a_k(g(w_k)+{\eta }_k)\\ =& w_k-{\alpha }_k(E[{\nabla }_{w}f(w_k,X)]+({\nabla }_{w}f(w_k,x_k)-E[{\nabla }_{w}f(w_k,X)]))\\ =& w_k-{\alpha }_k\cdot {\nabla }_{w}f(w_k,x_k)\end{array}$$

即 SGD。上式中 ${\eta }_k={\nabla }_{w}f(w_k,x_k)-E[{\nabla }_{w}f(w_k,X)]$，同样易证 $E[{\eta }_k]=0$ 且 $E[{\eta }_k^2]<\infty$。这里同时也说明了 SGD的收敛性，跟随 Robbins-Monro 框架的收敛性而成立

---

用 SGD 解释 Mean estimation

注意到如果想将 Mean estimation 套入 SGD 的框架，需要找到一个 $f(w,X)$ 使得满足：
$${\nabla }_{w}f(w,X)=w-X$$
因为这样就有：
$$w_{k+1}=w_k-{\alpha }_k\cdot {\nabla }_{w}f(w_k,x_k)=w_k-{\alpha }_k(w_k-x_k)$$
上式即 Mean estimation 的迭代式。因此我们可以构造：
$$\underset{w}{\min }J(w)=E[\frac{1}{2}||w-X|{|}^2]$$

这个从直观也比较好理解， 即求解 $w=E[X]$ 等价于求解 ${\min }_{w}E[\frac{1}{2}||w-X|{|}^2]$

---

SGD 的一个有趣的性质

尽管上面我们说明了 SGD 的收敛性，但它的收敛速度呢？是否也足够快呢？这里有一个有趣的结论：

当 $w_k$ 距离 $w^{\ast }$ 较远时，SGD 向 $w^{\ast }$ 靠近的速度与一般的 GD 差不多，但是当 $w_k$ 离 $w^{\ast }$ 比较近时，其收敛会呈现一定的 随机性

定义 $${\delta }_k=\frac{|{\nabla }_{w}f(w_k,x_k)-E[{\nabla }_{w}f(w_k,X)]|}{|E[{\nabla }_{w}f(w_k,X)]|}$$
来描述 SGD 和 GD 算法的相对误差，${\delta }_k$ 越小，表明 SGD 与 GD 的收敛速度越接近。

由于 $g(w^{\ast })={\nabla }_{w}J(w^{\ast })=E[{\nabla }_{w}f(w^{\ast },X)]=0$，因此
$${\delta }_k=\frac{|{\nabla }_{w}f(w_k,x_k)-E[{\nabla }_{w}f(w_k,X)]|}{|E[{\nabla }_{w}f(w_k,X)]-E[{\nabla }_{w}f(w^{\ast },X)]|}=\frac{|{\nabla }_{w}f(w_k,x_k)-E[{\nabla }_{w}f(w_k,X)]|}{E[{\nabla }_w^{2}f(\widehat{w_k},X)(w_k-w^{\ast })]}$$

其中总存在 $\widehat{w_k}\in (w_k,w^{\ast })$ ，使得 $E[{\nabla }_{w}f(w_k,X)]-E[{\nabla }_{w}f(w^{\ast },X)]=E[{\nabla }_w^{2}f(\widehat{w_k},X)(w_k-w^{\ast })]$ 是 中值定理 的结论。

由于 $w_k-w^{\ast }$ 不是随机变量，且由 Robbins-Monro 框架的收敛性条件，$0<c\le {\nabla }_w^{2}f$，可得：
$$|E[{\nabla }_w^{2}f(\widehat{w_k},X)(w_k-w^{\ast })]|=E[{\nabla }_w^{2}f(\widehat{w_k},X)]||w_k-w^{\ast }|\ge c|w_k-w^{\ast }|$$

$$\Rightarrow {\delta }_k\le \frac{|{\nabla }_{w}f(w_k,x_k)-E[{\nabla }_{w}f(w_k,X)]|}{c|w_k-w^{\ast }|}$$

因此我们可以发现：

• 当 $|w_k-w^{\ast }|$ 比较大时，${\delta }_k$ 的上界比较小，即此时 SGD 与 GD 的收敛速度比较接近
• 当 $|w_k-w^{\ast }|$ 比较小时，${\delta }_k$ 的上界比较大，即此时 SGD 的收敛速度不太能保证，有较强的 随机性

---

时序差分方法

时序差分方法也是一种 model-free 方法，类似 蒙特卡洛方法，我们有一个足够长的 trajectory $(s_0,r_1,s_1,...,s_t,r_{t+1},s_{t+1},...)$ 来作为样本集。回忆求解贝尔曼最优公式时的 策略迭代 过程

$$已知{\pi }_k\to (v_{{\pi }_k}^{(0)}\to v_{{\pi }_k}^{(1)}\to ...\to v_{{\pi }_k}^{(\infty )}=v_{{\pi }_k})\to 求解q_{{\pi }_k}(s,a)\to {\pi }_{k+1}=\{\begin{array}{l}1,a=a^{\ast }(s)\\ 0,a\ne a^{\ast }(s)\end{array}\to ...$$

其中 $(v_{{\pi }_k}^{(0)}\to v_{{\pi }_k}^{(1)}\to ...\to v_{{\pi }_k}^{(\infty )}=v_{{\pi }_k})$ 即是通过迭代求解一个求解一个贝尔曼公式：
$$\begin{array}{rl}{v}_{{\pi }_k}^{(1)}& =r_{{\pi }_k}+\gamma P_{{\pi }_k}{v}_{{\pi }_k}^{(0)}\\ v_{{\pi }_k}^{(2)}& =r_{{\pi }_k}+\gamma P_{{\pi }_k}{v}_{{\pi }_k}^{(1)}\\ & \dots \\ \text{贝尔曼公式}⟵v_{{\pi }_k}^{(\infty )}& =r_{{\pi }_k}+\gamma P_{{\pi }_k}{v}_{{\pi }_k}^{(\infty )}\end{array}$$

但现在由于是 model-free 了，我们只能通过样本来求解 $v_{{\pi }_k}$。在 第一节 中，$v_{{\pi }_k}$ 的原始定义是在 Policy 为 ${\pi }_k$， 从状态 s 出发时，所有可能的 trajectory 的 discounted return $G_t$ 的期望值：$$v_{\pi }(s)=E[G_t|S_t=s]=E[R_{t+1}+\gamma G_{t+1}|S_t=s]$$
又由于 $E[G_{t+1}|S_t=s]=v_{\pi }(S_{t+1})$

因此：
$$v_{\pi }(s)=E[R_{t+1}+\gamma v_{\pi }(S_{t+1})|S_t=s]$$

上式可以用 Robbins-Monro 框架来迭代求解：

记 $$g(v_{\pi }(s_t))=v_{\pi }(s_t)-E[R_{t+1}+\gamma v_{\pi }(S_{t+1})|S_t=s_t]$$
目标是求解： $$g(v_{\pi }(s_t))=0$$

上式就是我们前面讨论的 Mean estimation，每来一个样本 $(s_t,r_{t+1},s_{t+1})$，其更新式为：
$$v_{t+1}(s_t)=v_t(s_t)-{\alpha }_t(s_t)(v_t(s_t)-[r_{t+1}+\gamma v_t(s_{t+1})])$$

其中 $\overline{v_t}=r_{t+1}+\gamma v_t(s_{t+1})$ 称为 TD target，${\delta }_t=v_t(s_t)-\overline{v_t}$ 则称为 TD error。注意这里： $$v_{t+1}(s)=v_t(s)，\text{ if }s\ne s_t$$
即，每学习一个样本，$v_{t+1}$ 相比 $v_t$ 只会更新当前样本涉及到的 state 的 state value（这是当然的）。

如前面 Robbins-Monro 所讨论的，迭代的目标是减小 TD error，由于 $g(v_{\pi }(s_t))$ 是单调递增函数：

• 当 $v_t(s_t)-\overline{v_t}<0$ 时，$v_{t+1}(s_t)$ 往 $v_t(s_t)$ 右边移一点
• 当 $v_t(s_t)-\overline{v_t}>0$ 时，$v_{t+1}(s_t)$ 往 $v_t(s_t)$ 左边移一点

从数学上来说，因为当 $v_t=v_{\pi }$ 时：
$$\begin{array}{rl}E[{\delta }_t|S_t=s_t]& =E[v_{\pi }(S_t)-(R_{t+1}+\gamma v_{\pi }(S_{t+1}))|S_t=s_t]\\ & =v_{\pi }(s_t)-E[R_{t+1}+\gamma v_{\pi }(S_{t+1})|S_t=s_t]\\ & =0\end{array}$$

因此减小 TD error 即使得 $v_t$ 向 $v_{\pi }$ 靠近。

与蒙特卡洛算法的区别

1. 首先最主要的区别：TD 算法摆脱了蒙特卡洛算法中 需要等到所有的样本都采完，才能进行一轮更新。TD 算法中，每增加一个样本就可以进行一次 value state 更新
2. TD 算法由于每次只更新了一个样本，所以其开始的时候，是对 $R_{t+1}+\gamma G_{t+1}$ 的有偏估计，当学习的样本量足够多时，才逐渐变成无偏估计；而蒙特卡洛算法一条 trajectory 就采到足够多的样本，且一次迭代就全部使用，因此直接就是无偏估计
3. TD 算法估计的 state value，而蒙特卡洛方法是直接估计 action value

---

Sarsa 算法

上述 TD 算法只是求解了贝尔曼方程，但这不足以找到最优的 Policy，要找最优 Policy，需要知道所有 state 的 action value，回忆蒙特卡洛算法：

$$已知{\pi }_k\to 从(s,a)出发，做n次实验，有n个结果g_{{\pi }_k}^{(i)}(s,a)\to 估计q_{{\pi }_k}(s,a)=\frac{1}{n}\sum _i{g}_{{\pi }_k}^{(i)}(s,a)\to {\pi }_{k+1}=\{\begin{array}{l}1,a=a_{{\pi }_k}(s)\\ 0,a\ne a_{{\pi }_k}(s)\end{array}\to ...$$

这里我们也是想估计 $q_{{\pi }_k}(s,a)$，但类似 TD 算法的想法，Sarsa 算法也是来一个样本就学一点，而不是像蒙特卡洛算法一样等所有的样本都生成完了，再一起学。

第一节 当中，我们推到过 action value 形式的贝尔曼公式，首先看常见的 state value 的贝尔曼公式：
$$\begin{array}{r}{v}_{\pi }(s)=\sum _a\pi (a|s)[\sum _{r}P(r|s,a)r+\gamma \sum _{s^{\prime }}P(s^{\prime }|s,a)v_{\pi }(s^{\prime })],\forall s\end{array}$$
由于
$$v_{\pi }(s)=\sum _a\pi (a|s)q_{\pi }(s,a)$$
因此上式等价于
$$\begin{array}{rl}{q}_{\pi }(s,a)& =\sum _{r}P(r|s,a)r+\gamma \sum _{s^{\prime }}P(s^{\prime }|s,a)v_{\pi }(s^{\prime })\\ & =\sum _{r}P(r|s,a)r+\gamma \sum _{s^{\prime }}P(s^{\prime }|s,a)\sum _{a^{\prime }}{q}_{\pi }(s^{\prime },a^{\prime })\pi (a^{\prime }|s^{\prime })\\ & =\sum _{r}P(r|s,a)r+\gamma \sum _{s^{\prime }}\sum _{a^{\prime }}{q}_{\pi }(s^{\prime },a^{\prime })P(s^{\prime }|s,a)P(a^{\prime }|s^{\prime })\\ & =\sum _{r}P(r|s,a)r+\gamma \sum _{s^{\prime }}\sum _{a^{\prime }}{q}_{\pi }(s^{\prime },a^{\prime })P(s^{\prime }|s,a)P(a^{\prime }|s^{\prime },s,a)\\ & =\sum _{r}P(r|s,a)r+\gamma \sum _{s^{\prime }}\sum _{a^{\prime }}{q}_{\pi }(s^{\prime },a^{\prime })P(s^{\prime },a^{\prime }|s,a)\\ & =E[R+\gamma q_{\pi }(S^{\prime },A^{\prime })|s,a]\end{array}$$

因此 Sarsa 算法的 Robbins-Monro 框架为：

记 $$g(q_{\pi }(s_t,a_t))=q_{\pi }(s_t,a_t)-E[R_{t+1}+\gamma q_{\pi }(S_{t+1},A_{t+1})|S_t=s_t,A_t=a_t]$$
目标是求解： $g(q_{\pi }(s_t,a_t))=0$
\quad
每来一个样本 { s t , a t , r t + 1 , s t + 1 , a t + 1 } \{s_t, a_t, r_{t+1}, s_{t+1}, a_{t+1}\} {st​,at​,rt+1​,st+1​,at+1​}，更新式为： $$q_{t+1}(s_t,a_t)=q_t(s_t,a_t)-{\alpha }_t(s_t,a_t)[q_t(s_t,a_t)-(r_{t+1}+\gamma q_t(s_{t+1},a_{t+1}))]$$
同样有： $$q_{t+1}(s,a)=q_t(s,a),\forall (s,a)\ne (s_t,a_t)$$

Sarsa 算法的完整实现为：

这里面有一点需要注意，我们每采到一个样本 $(s_t,a_t,r_{t+1},s_{t+1},a_{t+1})$，就会立即更新 $q_{t+1}(s_t,a_t)$ 然后立马就更新 Policy ${\pi }_{t+1}$，并且由这个 Policy 来采下一个样本，这里采用 $ϵ$-greedy 方法来更新策略也是这个原因（即 Sarsa 是 on-policy 的，迭代中的策略同时也要用来生成下一步的样本）。

另外不难看出 Sarsa 找的 仅仅是从某一个 state 出发，到 target state 的最优路线，而不是求所有 state 的最优路线。因此 Sarsa 往往会主要在 start state 和 target state 附近寻找，因为一般情况下，最优路线也不会绕路。但理论上来说，不把所有的 state 都“走”足够多次，是 不能保证 Sarsa 找到的路径是 “全局最优” 的，有时也会出现只找到局部最优的情况。

一个例子

左边展示了 Sarsa 的结果，可以看出，它只是找到了从 start state 开始的一个最优路径，但是其他 state 的 policy 很多并不是最优的。右图显示了随着算法迭代，一个 episode 的长度和 reward，可以看到，随着迭代步数增加，episode 的长度减少，reward 增加，这些都说明，Policy 在不断变好。

---

Expected Sarsa 算法

Expected Sarsa 算法的迭代式与 Sarsa 非常接近：

$$\begin{array}{rl}{q}_{t+1}(s_t,a_t)& =q_t(s_t,a_t)-{\alpha }_t(s_t,a_t)[q_t(s_t,a_t)-(r_{t+1}+\gamma E[q_t(s_{t+1},A)])]\\ q_{t+1}(s,a)& =q_t(s,a),\forall (s,a)\ne (s_t,a_t)\end{array}$$

其中 $E[q_t(s_{t+1},A)]={\sum }_a{\pi }_t(a|s_{t+1})q_t(s_{t+1},a)=v_t(s_{t+1})$

上述迭代式也是基于求解贝尔曼公式：

$$\begin{array}{rl}{q}_{\pi }(s,a)& =E[R_{t+1}+\gamma E[q_{\pi }(S_{t+1},A_{t+1})|S_{t+1}]|S_t=s,A_t=a]\\ & =E[R_{t+1}+\gamma v_{\pi }(S_{t+1})|S_t=s,A_t=a]\end{array}$$

上式等价于贝尔曼公式的原因是：
$$\begin{array}{rl}{v}_{\pi }(s)& =E[R_{t+1}+\gamma v_{\pi }(S_{t+1})|S_t=s]\\ & =\sum _a\pi (a|s)E[R_{t+1}+\gamma v_{\pi }(S_{t+1})|S_t=s,A_t=a]\\ & =\sum _a\pi (a|s)q_{\pi }(s,a)\end{array}$$

Expected Sarsa 跟 Sarsa 相比：

1. TD target 计算更复杂了
2. 采样样本从 { s t , a t , r t + 1 , s t + 1 , a t + 1 } \{s_t, a_t, r_{t+1}, s_{t+1}, a_{t+1}\} {st​,at​,rt+1​,st+1​,at+1​} 变成了 { s t , a t , r t + 1 , s t + 1 } \{s_t, a_t, r_{t+1}, s_{t+1}\} {st​,at​,rt+1​,st+1​}，estimation variance 变小了

---

n-step Sarsa 算法

n-step Sarsa 是 Sarsa 的另一个重要变体，回忆 action value 的原始定义：$$q_{\pi }(s,a)=E[G_t|S_t=s,A_t=a]$$
$G_t$ 可以分解成 $$G_t=R_{t+1}+\gamma R_{t+2}+{\gamma }^2{R}_{t+3}+...$$
或者更细的拆分：
$$\begin{array}{rl}\text{Sarsa}\leftarrow G_t^{(1)}& =R_{t+1}+\gamma q_{\pi }(S_{t+1},A_{t+1})\\ G_t^{(2)}& =R_{t+1}+\gamma R_{t+2}+{\gamma }^2{q}_{\pi }(S_{t+2},A_{t+2})\\ \dots & \\ \text{n-step Sarsa}\leftarrow G_t^{(n)}& =R_{t+1}+\gamma R_{t+2}+...+{\gamma }^n{q}_{\pi }(S_{t+n},A_{t+n})\\ \dots & \\ \text{蒙特卡洛算法}\leftarrow G_t^{(\infty )}& =R_{t+1}+\gamma R_{t+2}+{\gamma }^2{R}_{t+3}+{\gamma }^3{R}_{t+4}+...\end{array}$$

即 Sarsa 是每拿到一个样本就更新，蒙特卡洛算法 是拿到所有样本再更新，而 n-step Sarsa 是拿到 n 个样本再更新

因此 n-step Sarsa 的效果也介于 Sarsa 和蒙特卡洛算法之间：

• 当 n 比较大时，更接近蒙特卡洛算法，此时其 bias 比较小，但 estimate variance 比较大
• 当 n 比较小时，更接近 Sarsa，此时其 bias 比较大，但 estimate variance 比较小

---

Q-learning 算法

Q-learning 跟上述 Sarsa 算法及其变种最主要的区别是：它是直接求的 optimal action value，这就意味着，它不需要像 Sarsa 一样，在每一步迭代后，专门再更新一下 Policy $\pi$ ，而是每次迭代直接就可得本次迭代后的最优的 Policy 了

直接给出 Q-learning 的迭代式：

$$\begin{array}{rl}{q}_{t+1}(s_t,a_t)& =q_t(s_t,a_t)-{\alpha }_t(s_t,a_t)[q_t(s_t,a_t)-(r_{t+1}+\gamma \underset{a}{\max }{q}_t(s_{t+1},a))]\\ q_{t+1}(s,a)& =q_t(s,a),\forall (s,a)\ne (s_t,a_t)\end{array}$$

Q-learning 的本质是 贝尔曼最优公式，这是因为：
$$\begin{array}{rl}q(s,a)& =E[R_{t+1}+\gamma \underset{a}{\max }q(S_{t+1},a)|S_t=s,A_t=a]\\ & =\sum _{r}P(r|s,a)r+\gamma \sum _{s^{\prime }}P(s^{\prime }|s,a)\underset{a}{\max }q(s^{\prime },a)\end{array}$$

由于 贝尔曼最优公式 ： $v^{\ast }(s)={\max }_{a}q(s,a)$，因此上式等价于
$$\begin{array}{rl}{v}^{\ast }(s)& =\underset{a}{\max }[\sum _{r}P(r|s,a)r+\gamma \sum _{s^{\prime }}P(s^{\prime }|s,a)v^{\ast }(s^{\prime })]\\ & =\underset{\pi }{\max }\sum _a\pi (a|s)[\sum _{r}P(r|s,a)r+\gamma \sum _{s^{\prime }}P(s^{\prime }|s,a)v^{\ast }(s^{\prime })]\end{array}$$

即为 第二节 中讨论的贝尔曼最优公式。

off-policy 和 on-policy

这是强化学习中一个比较基础而重要的概念。与深度学习不同，强化学习中其实有两种 Policy：

1. behavior policy：用于生成样本的 Policy
2. target policy：实际优化的 Policy
   \quad

off-policy 和 on-policy 分别指：

1. off-policy：behavior policy 和 target policy 不同
2. on-policy：behavior policy 和 target policy 是同一 Policy（我们前面讨论的绝大部分算法都是这种，这也是这些算法要用 $ϵ$-greedy 而不是直接 greedy 算法更新策略的原因）

Q-learning 是目前为止的第一个 off-policy 算法，核心原因就是因为它求解的是贝尔曼 最优 公式 ，而其他算法求解的只是贝尔曼公式，对比 Q-learning 和 Sarsa 的迭代式
$$\begin{array}{rl}\text{Q-learning : }{q}_{t+1}(s_t,a_t)& =q_t(s_t,a_t)-{\alpha }_t(s_t,a_t)[q_t(s_t,a_t)-(r_{t+1}+\gamma \underset{a}{\max }{q}_t(s_{t+1},a))]\\ \text{Sarsa : }{q}_{t+1}(s_t,a_t)& =q_t(s_t,a_t)-{\alpha }_t(s_t,a_t)[q_t(s_t,a_t)-(r_{t+1}+\gamma q_t(s_{t+1},a_{t+1}))]\end{array}$$
Sarsa 的一个样本是 { s t , a t , r t + 1 , s t + 1 , a t + 1 } \{s_t, a_t, r_{t+1}, s_{t+1}, a_{t+1}\} {st​,at​,rt+1​,st+1​,at+1​}，其中 $s_t,a_t$ 是当前步给定的，而 $r_{t+1},s_{t+1}$ 是仅依赖于 model： $P(R|s,a)$ 和 $P(S^{\prime }|s,a)$，与 Policy 无关。重点在于 $a_{t+1}$ ，一方面它依赖 behavior policy 生成，另一方面，它又用来更新了 target policy 的 action value，这就要求 $a_{t+1}$ 实际也是 target policy 在给定 $s_t,a_t$ 的选择（否则定义就不对了）

反观 Q-learning，由于它求解的是贝尔曼最优公式，所以它需要的样本为 { s t , a t , r t + 1 , s t + 1 } \{s_t, a_t, r_{t+1}, s_{t+1}\} {st​,at​,rt+1​,st+1​}，在给定 $s_t,a_t$ 时是不依赖 Policy 的，因此这里 target policy 可以和 behavior policy 解耦。因此它的 behavior policy 可以取得非常 exploration，这样可以使得取到的样本对每一个 state 都充分访问，也更有利于 target policy 的效果，以下是一个例子：

左边一列是 behavior policy，中间是生成的 episodes，右边一列是用于看 target policy 随着迭代的效果，可以看到，当 $ϵ$ 比较大时， behavior policy 探索性较强，对各个 state 的访问比较充分，其找到的 target policy 效果也更好。

下面再看一个例子，这个例子里，直接将 $ϵ$ 取为了1 （因此各个 action 概率均等）：

可以看到，此时 behavior policy 生成的 episodes 覆盖性更好，这使得 target policy 也能很快收敛

---

总结

下面我们给上述的各种时序差分算法一个综合的框架，并在这框架下看下每个算法的核心差别是什么：

$$q_{t+1}(s_t,a_t)=q_t(s_t,a_t)-\alpha (s_t,a_t)[q_t(s_t,a_t)-{\bar{q}}_t]$$

不难总结上述时序差分算法的迭代式都满足上述情况，具体来看：

---

Reference：
1.强化学习的数学原理