[归纳]强化学习导论 - 第十二章：资格迹

1. 本章内容概要

资格迹(eligibility trace)是RL的基本技术。例如，$\mathrm{TD}(\lambda )$算法就使用了资格迹，其中的$\lambda$表明该算法含有资格迹。几乎所有的TD方法(Q-learning，Sarsa)都能结合资格迹，使之更通用、更高效。

资格迹统一和泛化了TD与MC方法，使用资格迹增强TD方法，我们就像第一Part总结的一样，得到了算法族一个新的维度，一端是MC($\lambda =1$)，另一端是TD($\lambda =0$)，中间分布的方法则是其混合，往往在实际问题中效果更好。资格迹方法使得MC能在线的实现，即使对于continuing任务也能工作。

第七章中的n-step TD方法也是TD和MC的综合，但是资格迹的算法框架更加优雅，且具有计算优势。实际上资格迹的机制是引入了短记忆向量${\mathbf{z}}_t\in {\mathbb{R}}^d$，也叫做资格迹，而$\lambda$因子叫做迹衰减，满足$\lambda \in [0,1]$。不同于我们之前介绍的方法，我们之前介绍的方法都是需要后续n个状态的，叫做forward views，而资格迹则依赖前面的状态，叫做backward views，更容易实现，也更简洁。

其为何具有优势我们详细了解后就清楚了。像往常一样，我们先讨论状态值的预测，然后扩展到动作值，并讨论控制过程；在此基础上，扩展on-policy到off-policy的情形，并特别讨论线性拟合器的应用，此时资格迹的效果很好。所有这些讨论也是适用于表格与state aggregation的，它们是线性拟合器的特殊情形。

2. $\lambda$-return

带有拟合器的n-step return的形式为：
$G_{t:t+n}\doteq R_{t+1}+\gamma R_{t+2}+\cdots +{\gamma }^{n-1}{R}_{t+n}+{\gamma }^n\hat{v}\left(S_{t+n},{\mathbf{w}}_{t+n-1}\right),0\le t\le T-n$
当 $n\ge 1$时就可以根据这个return更新了。

如果把不同n的n-step return加权作为更新目标，且保证加权因子非负且和为1，那么也是有效的，能保证收敛，例如：$\frac{1}{2}{G}_{t:t+2}+\frac{1}{2}{G}_{t:t+4}$，把TD和MC混合，把TD/MC和DP混合等。 这种混合大大扩展了算法的种类。这种混合的更新叫做复合更新(compound update)，更新的时刻显然由最长的那个组分决定，其backup diagram如下：

TD($\lambda$)的return就是上述这种compound update，将无穷多n-step return加权，加权因子为$(1-\lambda ){\lambda }^{n-1}$，其更新目标叫做$\lambda$-return，$G_t^{\lambda }\doteq (1-\lambda ){\sum }_{n=1}^{\infty }{\lambda }^{n-1}{G}_{t:t+n}$。其backup diagram如下：

当$n\ge T$时，所有的return都认为等于$G_t$，因而有：$G_t^{\lambda }=(1-\lambda ){\sum }_{n=1}^{T-t-1}{\lambda }^{n-1}{G}_{t:t+n}+{\lambda }^{T-t-1}{G}_t$。显然，当$\lambda =1$时，相当于MC，当$\lambda =0$时，相当于TD(0)。容易地，我们可以仿照第三章写出这些return的迭代形式。权重因子$\lambda$的衰减曲线如下图所示：

下面介绍基于$\lambda$-return的第一个算法离线$\lambda$-return算法。离线指的是，在episode期间不进行权重更新，在episode结束的时候再根据得到的各个step的$G_t^{\lambda }$进行更新(即非in-place方式)。权重更新公式为：

${\mathbf{w}}_{t+1}\doteq {\mathbf{w}}_t+\alpha \left[G_t^{\lambda }-\hat{v}\left(S_t,{\mathbf{w}}_t\right)\right]\nabla \hat{v}\left(S_t,{\mathbf{w}}_t\right),t=0,\dots ,T-1$

对于我们前面介绍过的19状态random walk问题，我们分别用离线$\lambda$-return算法和n-step TD算法估计值函数，并变化步长$\alpha$以及$n$或$\lambda$，得到如下图所示的结果，看起来离线$\lambda$-return算法效果稍好，而且与n-step方法类似，也是当$\lambda$取适中的数字时效果最好。

这种方法也是forward view的，每个状态的更新都与后续状态有关。

3. TD($\lambda$)

TD($\lambda$)是RL中最古老、应用最广的算法。TD($\lambda$)相比于离线$\lambda$-return算法有三点改进：1. 在每个时间步都进行更新权重，而不是只在episode结尾一次性更新；2. 计算均匀地分布在每个step上；3. 可以用到continuing任务中。本节我们给出半梯度TD($\lambda$)算法。

资格迹是一个与权重向量${\text{w}}_t$元素数相等的向量${\mathbf{z}}_t\in {\mathbb{R}}^d$。权重向量${\text{w}}_t$是长期的记忆，而资格迹是短期的，往往维持的时间短于一个episode。资格迹的作用是辅助学习过程，对权重的更新造成一定的影响，然后由权重决定估计的值。

在TD($\lambda$)中，资格迹向量在每个episode开始时初始化未0，然后由下式逐step的更新：
${\mathbf{z}}_{-1}\doteq 0$
${\mathbf{z}}_t\doteq \gamma \lambda {\mathbf{z}}_{t-1}+\nabla \hat{v}\left(S_t,{\mathbf{w}}_t\right),0\le t\le T$
其中，$\gamma$是折扣因子，$\lambda$是资格迹的迹衰减因子。资格迹衡量的是最近哪个参数被修正的较多(对于线性模型，公式中的梯度就是输入的特征向量$\mathbf{x}(s)$，因此资格迹就是最近一些输入的加权和)。资格迹表征权重中的每个成分得到学习的潜力，因而我们得到TD($\lambda$)的更新公式：

${\delta }_t\doteq R_{t+1}+\gamma \hat{v}\left(S_{t+1},{\mathbf{w}}_t\right)-\hat{v}\left(S_t,{\mathbf{w}}_t\right)$
${\mathbf{w}}_{t+1}\doteq {\mathbf{w}}_t+\alpha {\delta }_t{\mathbf{z}}_t$

与之前的算法相比，梯度项包含在了${\mathbf{z}}_t$之中，且每个step的梯度不仅仅在这一步发生作用，它的作用会持续一段时间，逐渐衰减。其算法伪代码为：

这是一种backward view的算法，其更新机制如下图所示：

这个过程的推导其实不难(我尝试了下，觉得不难><)，思路为：

我们考虑几个特殊情况。当$\lambda =0$时，显然算法变成了半梯度TD(0)算法；当$\lambda =1$时，则算法叫做TD(1)，基本变为了MC方法[回顾下TD误差与MC误差的关系就能理解，参考第六章第二节]。当$\lambda$取中间数字时，则是两种方法的折中。

TD(1)是MC算法更通用的实现方式，极大增加了MC方法的应用范围，使之可以应用到continuing类的任务中，并且可以增量、在线的实现。关于在episode才更新的问题，这里给了另一种思路：如果在一个episode中间遇到了一个很好或者很差的动作，那么step-by-step的方法可以立即修改策略，使得这个episode后续的steps降低如此动作的概率；而在episode-by-episode的方法中则无法在episode中间提高策略，导致这个episode中的samples不太好。

回顾上一节介绍的离线$\lambda$-return算法，其也是在$\lambda =0$时等价于TD(0)，在$\lambda =1$时等价于MC。在19状态random-walk问题中，可以看出TD($\lambda$)的表现与离线$\lambda$-return算法是类似的。但是需要注意，当$\alpha$增大时，TD($\lambda$)的效果会迅速变坏，甚至会不稳定。

线性TD($\lambda$)在step-size满足第二章给出的收敛条件时，在on-policy情形下是能够收敛的，但是正如第九章中所提到的TD不动点，线性TD($\lambda$)也是收敛到靠近最优的一个点上，continuing任务的VE上界如下式所示：

$\overline{\mathrm{V}\mathrm{E}}\left({\mathbf{w}}_{\infty }\right)\le \frac{1-\gamma \lambda }{1-\gamma }{\min }_{\mathbf{w}}\overline{\mathrm{V}\mathrm{E}}(\mathbf{w})$

当$\lambda =1$时，线性TD($\lambda$)等价于MC，因此上界缩放系数是1；当$\lambda =0$时，线性TD($\lambda$)等价于TD(0)，因此上界缩放系数与TD不动点的缩放系数一致。$\lambda =1$是比较差的选择，后面我们会讨论这个问题。

离线$\lambda$-return算法的更新误差项(中括号里的)也可以写成TD误差之和的形式。

4. n-step截断$\lambda$-return方法

离线$\lambda$-return算法是重要的想法，但是由于$\lambda$-return只有在episode的末尾才能计算，因此造成计算分布不均衡，对于continuing任务甚至无法得到。实际上，由于因子$\gamma \lambda$的存在，计算$G_t^{\lambda }$时越往后的项发挥的作用越小，因此我们可以限制这个求和的长度。这就是截断$\lambda$-return方法，求和长度由horizon h决定：

$G_{t:h}^{\lambda }\doteq (1-\lambda ){\sum }_{n=1}^{h-t-1}{\lambda }^{n-1}{G}_{t:t+n}+{\lambda }^{h-t-1}{G}_{t:h},0\le t<h\le T$

这样的处理衍生出了一系列新的算法。如果应用于状态值函数，这族算法就叫做截断TD($\lambda$)或者TTD($\lambda$)。下图给出了它的backup diagram，注意$t+n\ge T$的情况：

TTD($\lambda$)的更新公式如下：

${\mathbf{w}}_{t+n}\doteq {\mathbf{w}}_{t+n-1}+\alpha \left[G_{t:t+n}^{\lambda }-\hat{v}\left(S_t,{\mathbf{w}}_{t+n-1}\right)\right]\nabla \hat{v}\left(S_t,{\mathbf{w}}_{t+n-1}\right),0\le t<T$

这个算法是比较高效的，但是需要注意，每个episode前n-1个step是不能更新的，而且需要终止状态后n-1个额外更新。 对$G_{t:h}^{\lambda }$也可以写成TD误差之和的形式：

$G_{t:t+k}^{\lambda }=\hat{v}\left(S_t,{\mathbf{w}}_{t-1}\right)+{\sum }_{i=t}^{t+k-1}(\gamma \lambda {)}^{i-t}{\delta }_i^{\prime }$
${\delta }_t^{\prime }\doteq R_{t+1}+\gamma \hat{v}\left(S_{t+1},{\mathbf{w}}_t\right)-\hat{v}\left(S_t,{\mathbf{w}}_{t-1}\right)$

5. 重新更新：在线$\lambda$-return算法

截断$\lambda$-return中n的选择是需要权衡的，大的n可以让算法更接近离线$\lambda$-return的性能，小的n可以减小更新延迟，尽快改变策略。我们可以以计算量提高为代价，得到同时拥有这两个优点的算法：也就是，在每个step，我们得到新的数据后，我们回溯再次更新episode中的每个step，直到该episode的起点。每次回溯的时候，我们相当于逐渐增大horizon，从而逐渐得到更好的结果。在这个过程中，我们需要始终保存${\mathbf{w}}_0$，每次我们前进一个step，到达step j，我们利用$G_{i:j}^{\lambda }，i=0,1,2,...,j$作为更新目标，再次从${\mathbf{w}}_0$出发更新参数，然后利用更新好的参数决定下一步动作。

为了区分不同step时的更新，我们在${\mathbf{w}}_0^h$中的上标表示目前进展到的step编号，下标仍然表示实际执行该更新所处的时间步，那么对于一个episode，step 1~3 时的更新为：

$\begin{array}{rl}h=1:& {\mathbf{w}}_1^1\doteq {\mathbf{w}}_0^1+\alpha \left[G_{0:1}^{\lambda }-\hat{v}\left(S_0,{\mathbf{w}}_0^1\right)\right]\nabla \hat{v}\left(S_0,{\mathbf{w}}_0^1\right)\end{array}$
$\begin{array}{rl}h=2:& {\mathbf{w}}_1^2\doteq {\mathbf{w}}_0^2+\alpha \left[G_{0:2}^{\lambda }-\hat{v}\left(S_0,{\mathbf{w}}_0^2\right)\right]\nabla \hat{v}\left(S_0,{\mathbf{w}}_0^2\right)\\ & {\mathbf{w}}_2^2\doteq {\mathbf{w}}_1^2+\alpha \left[G_{1:2}^{\lambda }-\hat{v}\left(S_1,{\mathbf{w}}_1^2\right)\right]\nabla \hat{v}\left(S_1,{\mathbf{w}}_1^2\right)\end{array}$
$\begin{array}{rl}h=3:& {\mathbf{w}}_1^3\doteq {\mathbf{w}}_0^3+\alpha \left[G_{0:3}^{\lambda }-\hat{v}\left(S_0,{\mathbf{w}}_0^3\right)\right]\nabla \hat{v}\left(S_0,{\mathbf{w}}_0^3\right)\\ & {\mathbf{w}}_2^3\doteq {\mathbf{w}}_1^3+\alpha \left[G_{1:3}^{\lambda }-\hat{v}\left(S_1,{\mathbf{w}}_1^3\right)\right]\nabla \hat{v}\left(S_1,{\mathbf{w}}_1^3\right)\\ & {\mathbf{w}}_3^3\doteq {\mathbf{w}}_2^3+\alpha \left[G_{2:3}^{\lambda }-\hat{v}\left(S_2,{\mathbf{w}}_2^3\right)\right]\nabla \hat{v}\left(S_2,{\mathbf{w}}_2^3\right)\end{array}$

更新公式为：
${\mathbf{w}}_{t+1}^h\doteq {\mathbf{w}}_t^h+\alpha \left[G_{t:h}^{\lambda }-\hat{v}\left(S_t,{\mathbf{w}}_t^h\right)\right]\nabla \hat{v}\left(S_t,{\mathbf{w}}_t^h\right),0\le t<h\le T$

定义${\mathbf{w}}_t\doteq {\mathbf{w}}_t^t$，则我们得到比较完整的表示。这个算法是完全在线的，在每个step都计算得到一个新的权重向量${\mathbf{w}}_t$，且只利用到时间步t为止的信息。这个方法计算复杂度很高，比离线$\lambda$-return算法还要复杂很多，但是学习效率是比离线方法好很多的。

回到19状态random walk问题，可以看到在线方法确实比离线方法好。

6. 真正的在线TD($\lambda$)

在线方法效果是目前所有算法中最好的，但是计算量过大，我们可以考虑资格迹的方法简化它，也就是采用backward-view的视角，这对于线性拟合器来说是可行的。这种方法就叫做真正在线TD($\lambda$)算法。

该方法的推导是很复杂的(参考下一节介绍及文献van Seijen et al., 2016)，所以这里没有详述，但是给出了参考文献。其实它的思想是简单的。首先，我们把离线算法的所有中间权重列成三角形，每一行都是单个推进的step基础上产生的，我们关心的只是右侧倾斜排列的那些权重：

$\begin{array}{cccccc}{\mathbf{w}}_0^0& & & & & \\ {\mathbf{w}}_0^1& {\mathbf{w}}_1^1& & & & \\ {\mathbf{w}}_0^2& {\mathbf{w}}_1^2& {\mathbf{w}}_2^2& & & \\ {\mathbf{w}}_0^3& {\mathbf{w}}_1^3& {\mathbf{w}}_2^3& {\mathbf{w}}_3^3& & \\ ⋮& ⋮& ⋮& ⋮& \ddots & \\ {\mathbf{w}}_0^T& {\mathbf{w}}_1^T& {\mathbf{w}}_2^T& {\mathbf{w}}_3^T& \cdots & {\mathbf{w}}_T^T\end{array}$

如果我们能从上一个${\mathbf{w}}_t^t$计算出下一个，那么就能作为离线算法的高效形式。对于线性拟合器，可以得到如下形式：

${\mathbf{w}}_{t+1}\doteq {\mathbf{w}}_t+\alpha {\delta }_t{\mathbf{z}}_t+\alpha \left({\mathbf{w}}_t^{\top }{\mathbf{x}}_t-{\mathbf{w}}_{t-1}^{\top }{\mathbf{x}}_t\right)\left({\mathbf{z}}_t-{\mathbf{x}}_t\right)$

${\mathbf{z}}_t\doteq \gamma \lambda {\mathbf{z}}_{t-1}+\left(1-\alpha \gamma \lambda {\mathbf{z}}_{t-1}^{\top }{\mathbf{x}}_t\right){\mathbf{x}}_t$

可以证明，这个算法和离线算法的效果是一致的，计算量仅仅比普通的TD($\lambda$)算法高50%，还是O(d)，而存储量则与普通TD($\lambda$)算法一致。该算法的伪代码如下：

为了区分目前提到的两种资格迹，这一节的方法叫做dutch trace，之前介绍的方法叫做accumulating trace。早期的工作常用一种叫做replacing trace的形式(可以粗略地看作dutch trace的近似)，这种形式只对表格情形/二进制编码情形(如tile coding)有效，其定义为：

$z_{i,t}\doteq \{\begin{array}{ll}1& \text{ if }{x}_{i,t}=1\\ \gamma \lambda z_{i,t-1}& \text{ otherwise }\end{array}$

注意这里两个下标，第一个下标表明是资格迹的分量，第二个下标表明时间步。dutch trace比replacing trace表现好，且理论依据明确，accumulating trace则对非线性方法也适用，但是dutch trace则不适用。

7. MC学习中的Dutch Trace

虽然资格迹在发展上和TD很密切，但实际上却没那么紧密，因为我们可以看到资格迹与MC方法也是有关联的。我们前面已经示意，线性MC这种forward view算法，可以由与其等价的使用dutch traces的backward view算法代替，且大大降低计算量。我们这里对其等价性给出证明，这个证明对真正在线TD($\lambda$)算法与在线TD($\lambda$)算法的等价性证明有启发作用。

MC算法的线性版本更新公式如下：
${\mathbf{w}}_{t+1}\doteq {\mathbf{w}}_t+\alpha \left[G-{\mathbf{w}}_t^{\top }{\mathbf{x}}_t\right]{\mathbf{x}}_t,0\le t<T$

为了简化，假设只有在episode的结尾才有非零的reward，且折扣因子为1.0，因此在任何step t，更新目标都是一样的，因此直接用G表示。作为MC算法，所有的更新都依赖于最终的reward，而这必须等到episode的结尾，因此MC算法是离线的。但是这里我们首先不去寻求改成在线的方法，我们主要关注如何提高计算效率。我们在episode中间进行计算，但是在episode的结尾再更新，这样可以让计算的分布更加均匀，每个step都是$O(d)$的复杂度，同时也降低了内存开销，因为不需要存储中间的step了。资格迹的方法就实现了这样的效果，且其与MC方法是等价的：

$\begin{array}{rl}{\mathbf{w}}_T& ={\mathbf{w}}_{T-1}+\alpha \left(G-{\mathbf{w}}_{T-1}^{\top }{\mathbf{x}}_{T-1}\right){\mathbf{x}}_{T-1}\\ & ={\mathbf{w}}_{T-1}+\alpha {\mathbf{x}}_{T-1}\left(-{\mathbf{x}}_{T-1}^{\top }{\mathbf{w}}_{T-1}\right)+\alpha G{\mathbf{x}}_{T-1}\\ & =\left(\mathbf{I}-\alpha {\mathbf{x}}_{T-1}{\mathbf{x}}_{T-1}^{\top }\right){\mathbf{w}}_{T-1}+\alpha G{\mathbf{x}}_{T-1}\\ & ={\mathbf{F}}_{T-1}{\mathbf{w}}_{T-1}+\alpha G{\mathbf{x}}_{T-1}\\ & ={\mathbf{F}}_{T-1}\left({\mathbf{F}}_{T-2}{\mathbf{w}}_{T-2}+\alpha G{\mathbf{x}}_{T-2}\right)+\alpha G{\mathbf{x}}_{T-1}\\ & ={\mathbf{F}}_{T-1}{\mathbf{F}}_{T-2}{\mathbf{w}}_{T-2}+\alpha G\left({\mathbf{F}}_{T-1}{\mathbf{x}}_{T-2}+{\mathbf{x}}_{T-1}\right)\\ & ={\mathbf{F}}_{T-1}{\mathbf{F}}_{T-2}\left({\mathbf{F}}_{T-3}{\mathbf{w}}_{T-3}+\alpha G{\mathbf{x}}_{T-3}\right)+\alpha G\left({\mathbf{F}}_{T-1}{\mathbf{x}}_{T-2}+{\mathbf{x}}_{T-1}\right)\\ & ={\mathbf{F}}_{T-1}{\mathbf{F}}_{T-2}{\mathbf{F}}_{T-3}{\mathbf{w}}_{T-3}+\alpha G\left({\mathbf{F}}_{T-1}{\mathbf{F}}_{T-2}{\mathbf{x}}_{T-3}+{\mathbf{F}}_{T-1}{\mathbf{X}}_{T-2}+{\mathbf{x}}_{T-1}\right)\\ & ⋮\\ & =\underset{{\mathbf{a}}_{T-1}}{\underbrace{{\mathbf{F}}_{T-1}{\mathbf{F}}_{T-2}\cdots {\mathbf{F}}_0{\mathbf{w}}_0}}+\alpha G\underset{{\mathbf{z}}_{T-1}}{\underbrace{\sum _{k=0}^{T-1}{\mathbf{F}}_{T-1}{\mathbf{F}}_{T-2}\cdots {\mathbf{F}}_{k+1}{\mathbf{x}}_k}}\\ & ={\mathbf{a}}_{T-1}+\alpha G{\mathbf{z}}_{T-1}\end{array}$

这两项都可以逐step计算的，且与$G$无关，${\mathbf{F}}_t\doteq \mathbf{I}-\alpha {\mathbf{x}}_t{\mathbf{x}}_t^{\top }$只与第t个step的特征向量有关，因而${\mathbf{a}}_{T-1}$很容易逐step地计算：

${\mathbf{a}}_t\doteq {\mathbf{F}}_t{\mathbf{F}}_{t-1}\cdots {\mathbf{F}}_0{\mathbf{w}}_0={\mathbf{F}}_t{\mathbf{a}}_{t-1}={\mathbf{a}}_{t-1}-\alpha {\mathbf{x}}_t{\mathbf{x}}_t^{\top }{\mathbf{a}}_{t-1},1\le t<T$

而${\mathbf{z}}_{T-1}$也可以迭代地计算，实际上是dutch风格的资格迹($\gamma \lambda =1$)，初始化为${\mathbf{z}}_0={\mathbf{x}}_0$并根据下式迭代：

$\begin{array}{rl}{\mathbf{z}}_t& \doteq \sum _{k=0}^t{\mathbf{F}}_t{\mathbf{F}}_{t-1}\cdots {\mathbf{F}}_{k+1}{\mathbf{x}}_k,1\le t<T\\ & =\sum _{k=0}^{t-1}{\mathbf{F}}_t{\mathbf{F}}_{t-1}\cdots {\mathbf{F}}_{k+1}{\mathbf{x}}_k+{\mathbf{x}}_t\\ & ={\mathbf{F}}_t\sum _{k=0}^{t-1}{\mathbf{F}}_{t-1}{\mathbf{F}}_{t-2}\cdots {\mathbf{F}}_{k+1}{\mathbf{x}}_k+{\mathbf{x}}_t\\ & ={\mathbf{F}}_t{\mathbf{z}}_{t-1}+{\mathbf{x}}_t\\ & =\left(\mathbf{I}-\alpha {\mathbf{x}}_t{\mathbf{x}}_t^{\top }\right){\mathbf{z}}_{t-1}+{\mathbf{x}}_t\\ & ={\mathbf{z}}_{t-1}-\alpha {\mathbf{x}}_t{\mathbf{x}}_t^{\top }{\mathbf{z}}_{t-1}+{\mathbf{x}}_t\\ & ={\mathbf{z}}_{t-1}-\alpha \left({\mathbf{z}}_{t-1}^{\top }{\mathbf{x}}_t\right){\mathbf{x}}_t+{\mathbf{x}}_t\\ & ={\mathbf{z}}_{t-1}+\left(1-\alpha {\mathbf{z}}_{t-1}^{\top }{\mathbf{x}}_t\right){\mathbf{x}}_t\end{array}$

可以看到这就是上一小节的dutch风格的迹的形式。

以上过程等价于所设定条件下的MC/LMS方法，但是改善了计算和存储过程，这说明资格迹与TD方法关联没那么紧密，是更基础底层的技巧。因此，在需要学习长期预测时都可以应用资格迹的技巧。

8. Sarsa($\lambda$)

这里开始讨论如何在动作值上应用资格迹，实际上需要的变化很少。首先给出n-step return的动作值版本：

$G_{t:t+n}\doteq R_{t+1}+\cdots +{\gamma }^{n-1}{R}_{t+n}+{\gamma }^n\hat{q}\left(S_{t+n},A_{t+n},{\mathbf{w}}_{t+n-1}\right),t+n<T$

其中，$G_{t:t+n}\doteq G_t$ 如果 $t+n\ge T$。

动作值版本的离线$\lambda$-return算法更新公式为：

${\mathbf{w}}_{t+1}\doteq {\mathbf{w}}_t+\alpha \left[G_t^{\lambda }-\hat{q}\left(S_t,A_t,{\mathbf{w}}_t\right)\right]\nabla \hat{q}\left(S_t,A_t,{\mathbf{w}}_t\right),t=0,\dots ,T-1$

其中，$G_t^{\lambda }\doteq G_{t:\infty }^{\lambda }$。下图给出了其backup diagram，和TD($\lambda$)算法是差不多的。引入资格迹，就得到了Sarsa($\lambda$)，和TD($\lambda$)是类似的：

${\mathbf{w}}_{t+1}\doteq {\mathbf{w}}_t+\alpha {\delta }_t{\mathbf{z}}_t$
${\delta }_t\doteq R_{t+1}+\gamma \hat{q}\left(S_{t+1},A_{t+1},{\mathbf{w}}_t\right)-\hat{q}\left(S_t,A_t,{\mathbf{w}}_t\right)$
${\mathrm{z}}_{-1}\doteq 0$
${\mathrm{z}}_t\doteq \gamma \lambda {\mathrm{z}}_{t-1}+\nabla \hat{q}\left(S_t,A_t,{\mathrm{w}}_t\right),0\le t\le T$

带有线性拟合器、二进制编码特征、使用accumulating或replacing迹的Sarsa($\lambda$)的伪代码如下，其显示了在这个特殊设定下算法的进一步简化：

这个算法也可以使用dutch迹。

example 12.1 Traces in Gridworld
使用资格迹可以提高控制算法的效率，比one-step方法甚至n-step方法都要好的。对于Gridworld问题，设定值函数初始都是0，所有回报，除了终止状态都是0，终止状态的回报是正数。用箭头表示得到提高的状态-动作对，箭头的大小表示经验信息对更新指引的程度($\lambda$)。则能得到如下结果：

example 12.2 Sarsa($\lambda$) on Mountain Car
对第十章中的Mountain Car问题，我们采用Sarsa($\lambda$)求解，并变化参数$\lambda$画出多条曲线。可以看到Sarsa($\lambda$)比n-step方法看起来好很多：

当然，也可以写出动作值版本的在线$\lambda$-return算法，以及其高效的实现真正在线Sarsa($\lambda$)。这两种算法与前面介绍的状态值的版本基本是一样的。其算法伪代码如下：

下图给出了不同版本的Sarsa($\lambda$)在Mountain Car问题上的表现：

此外，还有截断版本的Sarsa($\lambda$)，叫做forward Sarsa($\lambda$)，其效果也是不错的(van Seijen, 2016)。

9. 变量$\lambda$和$\gamma$

到这里，我们就完成了基本的TD学习的全部进展。我们可以把bootstrapping和discounting的程度改写成状态和动作的函数，而不是固定的参数，这样每个step我们就会有不同的$\lambda$和$\gamma$，即：${\lambda }_t$ 和 ${\gamma }_t$。因此，我们定义$\lambda :\mathcal{S}\times \mathcal{A}\to [0,1]$是[0, 1]值域的状态和动作的函数，记为${\lambda }_t\doteq \lambda \left(S_t,A_t\right)$，定义$\gamma :\mathcal{S}\to [0,1]$是[0, 1]值域的状态的函数，记为${\gamma }_t\doteq \gamma \left(S_t\right)$，也叫做termination function。

这样，我们可以写出更一般的return定义：

$\begin{array}{rl}{G}_t& \doteq R_{t+1}+{\gamma }_{t+1}{G}_{t+1}\\ & =R_{t+1}+{\gamma }_{t+1}{R}_{t+2}+{\gamma }_{t+1}{\gamma }_{t+2}{R}_{t+3}+{\gamma }_{t+1}{\gamma }_{t+2}{\gamma }_{t+3}{R}_{t+4}+\cdots \\ & =\sum _{k=t}^{\infty }\left(\prod _{i=t+1}^k{\gamma }_i\right)R_{k+1}\end{array}$

为了保证收敛，要求${\prod }_{k=t}^{\infty }{\gamma }_k=0$对所有的t，依概率1成立。这种写法带来了一些好处，例如我们不必再针对episodic类任务定义终止状态了，只需令对应状态的$\gamma (s)=0$，并转移到起始状态即可。依状态的终止，包括之前为了降低方差引入的伪终止，都可以用这种方法处理。因此，这种方法统一了episodic和discounted-continuing情形(undiscounted-continuing仍需特殊处理)。

基于$\lambda$函数的$\lambda$-return更新目标需要改写为迭代形式，由上面给出的$G_t$的定义以及$\lambda$-return的原始定义可以导出：$G_t^{\lambda s}\doteq R_{t+1}+{\gamma }_{t+1}\left(\left(1-{\lambda }_{t+1}\right)\hat{v}\left(S_{t+1},{\mathbf{w}}_t\right)+{\lambda }_{t+1}{G}_{t+1}^{\lambda s}\right)$。$\lambda s$表示这个return是从状态值bootstrap的，后面我们引入的$\lambda a$则表明这个return是从动作值bootstrap的。对于动作值的$\lambda$-return，可以写成Sarsa或者Expected Sarsa的形式：
Sarsa:
$G_t^{\lambda a}\doteq R_{t+1}+{\gamma }_{t+1}\left(\left(1-{\lambda }_{t+1}\right)\hat{q}\left(S_{t+1},A_{t+1},{\mathbf{w}}_t\right)+{\lambda }_{t+1}{G}_{t+1}^{\lambda a}\right)$
Expected Sarsa:
$G_t^{\lambda a}\doteq R_{t+1}+{\gamma }_{t+1}\left(\left(1-{\lambda }_{t+1}\right){\overline{V}}_t\left(S_{t+1}\right)+{\lambda }_{t+1}{G}_{t+1}^{\lambda a}\right)$
${\overline{V}}_t(s)\doteq {\sum }_a\pi (a|s)\hat{q}\left(s,a,{\mathbf{w}}_t\right)$

10. 带有控制变异(Control Variates)的离线迹

最后，我们考虑off-policy下的情形，此时需要引入重要性采样。不像n-step情形，我们无法使重要性采样独立于目标return，因此此处直接采用带有控制变异的per-decision方式，结合上一节的式子，得到：

$G_t^{\lambda s}\doteq {\rho }_t\left(R_{t+1}+{\gamma }_{t+1}\left(\left(1-{\lambda }_{t+1}\right)\hat{v}\left(S_{t+1},{\mathbf{w}}_t\right)+{\lambda }_{t+1}{G}_{t+1}^{\lambda s}\right)\right)+\left(1-{\rho }_t\right)\hat{v}\left(S_t,{\mathbf{w}}_t\right)$

以上公式可以参考第7.5小节。

其中，${\rho }_t=\frac{\pi \left(A_t|S_t\right)}{b\left(A_t|S_t\right)}$。这个式子约等于基于状态的TD误差的和(如果估计的值函数不变的话，就变得准确了)：
${\delta }_t^s\doteq R_{t+1}+{\gamma }_{t+1}\hat{v}\left(S_{t+1},{\mathbf{w}}_t\right)-\hat{v}\left(S_t,{\mathbf{w}}_t\right)$
$G_t^{\lambda s}\approx \hat{v}\left(S_t,{\mathbf{w}}_t\right)+{\rho }_t{\sum }_{k=t}^{\infty }{\delta }_k^s{\prod }_{i=t+1}^k{\gamma }_i{\lambda }_i{\rho }_i$

forward view的更新公式为：
$\begin{array}{rl}{\mathbf{w}}_{t+1}& ={\mathbf{w}}_t+\alpha \left(G_t^{\lambda s}-\hat{v}\left(S_t,{\mathbf{w}}_t\right)\right)\nabla \hat{v}\left(S_t,{\mathbf{w}}_t\right)\\ & \approx {\mathbf{w}}_t+\alpha {\rho }_t\left(\sum _{k=t}^{\infty }{\delta }_k^s\prod _{i=t+1}^k{\gamma }_i{\lambda }_i{\rho }_i\right)\nabla \hat{v}\left(S_t,{\mathbf{w}}_t\right)\end{array}$

这看起来像基于资格迹的TD更新，乘积和资格迹类似，然后乘上TD误差。但是这种只是one-step forward view。我们希望寻找将forward-view更新沿时间加和，把backward-view也沿着时间加和，使这两个和大致相等。forward-view沿着时间的加和为：

$\begin{array}{rl}\sum _{t=1}^{\infty }\left({\mathbf{w}}_{t+1}-{\mathbf{w}}_t\right)& \approx \sum _{t=1}^{\infty }\sum _{k=t}^{\infty }\alpha {\rho }_t{\delta }_k^s\nabla \hat{v}\left(S_t,{\mathbf{w}}_t\right)\prod _{i=t+1}^k{\gamma }_i{\lambda }_i{\rho }_i\\ & =\sum _{k=1}^{\infty }\sum _{t=1}^k\alpha {\rho }_t\nabla \hat{v}\left(S_t,{\mathbf{w}}_t\right){\delta }_k^s\prod _{i=t+1}^k{\gamma }_i{\lambda }_i{\rho }_i\\ & =\sum _{k=1}^{\infty }\alpha {\delta }_k^s\sum _{t=1}^k{\rho }_t\nabla \hat{v}\left(S_t,{\mathbf{w}}_t\right)\prod _{i=t+1}^k{\gamma }_i{\lambda }_i{\rho }_i\end{array}$

如果第二个求和可以写成并按照资格迹的形式增量更新，这个式子就能构成backward-view TD更新的加和形式，我们下面给出如何实现。如果表达式是在时刻k的迹，我们就能用k-1时刻的值更新它：

$\begin{array}{rl}{\mathbf{z}}_k& =\sum _{t=1}^k{\rho }_t\nabla \hat{v}\left(S_t,{\mathbf{w}}_t\right)\prod _{i=t+1}^k{\gamma }_i{\lambda }_i{\rho }_i\\ & =\sum _{t=1}^{k-1}{\rho }_t\nabla \hat{v}\left(S_t,{\mathbf{w}}_t\right)\prod _{i=t+1}^k{\gamma }_i{\lambda }_i{\rho }_i+{\rho }_k\nabla \hat{v}\left(S_k,{\mathbf{w}}_k\right)\\ & ={\gamma }_k{\lambda }_k{\rho }_k\underset{{\mathbf{z}}_{\mathbf{k}-1}}{\underbrace{\sum _{t=1}^{k-1}{\rho }_t\nabla \hat{v}\left(S_t,{\mathbf{w}}_t\right)\prod _{i=t+1}^{k-1}{\gamma }_i{\lambda }_i{\rho }_i}}+{\rho }_k\nabla \hat{v}\left(S_k,{\mathbf{w}}_k\right)\\ & ={\rho }_k\left({\gamma }_k{\lambda }_k{\mathbf{z}}_{k-1}+\nabla \hat{v}\left(S_k,{\mathbf{w}}_k\right)\right)\end{array}$

下标则从k变化到t，是针对状态值常规的accumulating迹更新：
${\mathbf{z}}_t\doteq {\rho }_t\left({\gamma }_t{\lambda }_t{\mathbf{z}}_{t-1}+\nabla \hat{v}\left(S_t,{\mathbf{w}}_t\right)\right)$

这个资格迹，结合TD($\lambda$)的半梯度参数更新规则${\mathbf{w}}_{t+1}\doteq {\mathbf{w}}_t+\alpha {\delta }_t{\mathbf{z}}_t$，可以构成既可用于on-policy也可用于off-policy的通用TD($\lambda$)算法。在on-policy情形下，这个算法就退化为$\mathrm{T}\mathrm{D}(\lambda )$。在off-policy情形，这个算法通常效果很好，但是却不能保证收敛稳定，因为其是半梯度的。在之后几个章节中，我们会改造这个算法使之稳定。

对于动作值的off-policy资格迹及与之相关Sarsa($\lambda$)算法，也可访上导出。我们可以从迭代或者一般形式的动作值$\lambda$-return开始，也就是：
$G_t^{\lambda a}\doteq R_{t+1}+{\gamma }_{t+1}\left(\left(1-{\lambda }_{t+1}\right)\hat{q}\left(S_{t+1},A_{t+1},{\mathbf{w}}_t\right)+{\lambda }_{t+1}{G}_{t+1}^{\lambda a}\right)$
$G_t^{\lambda a}\doteq R_{t+1}+{\gamma }_{t+1}\left(\left(1-{\lambda }_{t+1}\right){\overline{V}}_t\left(S_{t+1}\right)+{\lambda }_{t+1}{G}_{t+1}^{\lambda a}\right)$
但是Expected Sarsa(后者)形式的更容易推导。我们把其拓展到off-policy情形，并结合七章中的控制变体方法：

$\begin{array}{rl}{G}_t^{\lambda a}& \doteq R_{t+1}+{\gamma }_{t+1}\left(\left(1-{\lambda }_{t+1}\right){\overline{V}}_t\left(S_{t+1}\right)+{\lambda }_{t+1}\left[{\rho }_{t+1}{G}_{t+1}^{\lambda a}+{\overline{V}}_t\left(S_{t+1}\right)-{\rho }_{t+1}\hat{q}\left(S_{t+1},A_{t+1},{\mathbf{w}}_t\right)\right]\right)\\ & =R_{t+1}+{\gamma }_{t+1}\left({\overline{V}}_t\left(S_{t+1}\right)+{\lambda }_{t+1}{\rho }_{t+1}\left[G_{t+1}^{\lambda a}-\hat{q}\left(S_{t+1},A_{t+1},{\mathbf{w}}_t\right)\right]\right)\end{array}$

其中，${\overline{V}}_t\left(S_{t+1}\right)$与之前定义的一致：${\overline{V}}_t(s)\doteq {\sum }_a\pi (a|s)\hat{q}\left(s,a,{\mathbf{w}}_t\right)$。再次，$\lambda$-return可以写成近似的形式(TD误差之和)：

$G_t^{\lambda a}\approx \hat{q}\left(S_t,A_t,{\mathbf{w}}_t\right)+{\sum }_{k=t}^{\infty }{\delta }_k^a{\prod }_{i=t+1}^k{\gamma }_i{\lambda }_i{\rho }_i$

使用期望形式的动作值TD误差：
${\delta }_t^a=R_{t+1}+{\gamma }_{t+1}{\overline{V}}_t\left(S_{t+1}\right)-\hat{q}\left(S_t,A_t,{\mathbf{w}}_t\right)$

和之前一样，当近似值函数不变化的话，则这个近似公式就很准确了。

参考针对状态值的处理，我们能写出forward-view的更新，得到如下的形式：
${\mathbf{z}}_t\doteq {\gamma }_t{\lambda }_t{\rho }_t{\mathbf{z}}_{t-1}+\nabla \hat{q}\left(S_t,A_t,{\mathbf{w}}_t\right)$

这个资格迹和期望形式TD误差一起，以及半梯度参数更新方法，就构成了优雅、高效的Expected Sarsa($\lambda$)算法，这个算法既可以应用到on-policy情形，也可以应用到off-policy情形。这可能是目前此类算法中最好的一个(但是这个原始版本不保证收敛稳定，加入后续小节的技巧就能保证稳定了)。在on-policy情形时，固定$\lambda$和$\gamma$和动作值的TD误差，这个算法就和Sarsa($\lambda$)一样了。

当$\lambda =1$时，这些算法就和MC算法非常相关了，对于episodic问题，如果采用offline更新策略，则和MC方法完全一致。但实际上，这种关联性是比较微妙的，在这些条件下，实际上只是期望上等价，episode-by-episode的更新并不等价。这是不奇怪的，因为在轨迹展开的过程中，这些方法都是要更新的，然而对于MC方法，如果实际采取的某个动作对于target policy来说是0概率的，那么就不会针对这个轨迹更新了。特别地，所有这些方法，在$\lambda =1$时，实际上还是有bootstrap的，因为target依赖于当前的估计值，只有在期望形式的时候，这种依赖才能去掉。这些方法需要额外的临时权重，来跟踪updates，这些updates需要根据后续的动作逐渐衰减。状态和状态动作版本的方法叫做PTD($\lambda$)和PQ($\lambda$)，其中P表示临时的。

这些新的off-policy方法的效果目前还不明确，但是无可置疑的，因为这些方法在off-policy情形下都包含重要性采样，因此其方差是比较大的。

如果$\lambda <1$，那么所有这些off-policy算法都包含bootstrapping，且符合死亡三角，这意味着只有在表格、state aggregation、或者其它受限拟合器的情形下才能保证稳定。对于线性和更一般的拟合器形式，其参数可能发散。正如我们之前讨论的，off-policy的挑战包含两部分，off-policy资格迹能高效地处理第一个挑战，但是对于第二个挑战却没法克服。对于第二个挑战的解决，我们在12节中给出一些方法。

11. Watkins的Q($\lambda$)到Tree-Backup($\lambda$)

为了在Q学习中使用资格迹，已经有几种方法提出来了。最早的方法就是Watkins的Q($\lambda$)，只要采取greedy的动作，就像之前介绍的逐渐衰减资格迹，然后在第一个non-greedy的位置把迹置为0。Watkins的Q($\lambda$)的backup diagram如下图所示：

在第六章中，我们给出了 Q-learning 和 Expected Sarsa 的统一框架，并在之后给出了其 off-policy 的版本，在这个框架中，Q-learning 是特殊的情形，且可以泛化到任意的 target policy 上。在之前的章节中，我们已经把 Expected Sarsa 融入了 off-policy 资格迹，在第七章中，我们给出了 n-step Tree Backup 方法，它能处理 off-policy 情形，且不需要显式的重要性采样，在资格迹版本的 Q 算法中，我们也采用这个方法，叫做Tree-Backup($\lambda$)，简称TD($\lambda$)。

TD($\lambda$)的概念是很直接的，如下图所示

每个长度的tree-backup更新由bootstrapping参数$\lambda$决定，为了得到方程，我们从$\lambda$-return的迭代形式出发：

$\begin{array}{rl}{G}_t^{\lambda a}& \doteq R_{t+1}+{\gamma }_{t+1}\left(\left(1-{\lambda }_{t+1}\right){\overline{V}}_t\left(S_{t+1}\right)+{\lambda }_{t+1}\left[\sum _{a̸=A_{t+1}}\pi \left(a|S_{t+1}\right)\hat{q}\left(S_{t+1},a,{\mathbf{w}}_t\right)+\pi \left(A_{t+1}|S_{t+1}\right)G_{t+1}^{\lambda a}\right]\right)\\ & =R_{t+1}+{\gamma }_{t+1}\left({\overline{V}}_t\left(S_{t+1}\right)+{\lambda }_{t+1}\pi \left(A_{t+1}|S_{t+1}\right)\left(G_{t+1}^{\lambda a}-\hat{q}\left(S_{t+1},A_{t+1},{\mathbf{w}}_t\right)\right)\right)\end{array}$

依据通常的处理方式，我们可以写出其TD误差和的近似形式(忽略估计的值函数的变化)：
$G_t^{\lambda a}\approx \hat{q}\left(S_t,A_t,{\mathbf{w}}_t\right)+{\sum }_{k=t}^{\infty }{\delta }_k^a{\prod }_{i=t+1}^k{\gamma }_i{\lambda }_i\pi \left(A_i|S_i\right)$

这里使用了基于动作的TD误差的期望形式。

依照前面章节相同的步骤，我们可以得到考虑target policy动作选择概率的资格迹更新：
${\mathbf{z}}_t\doteq {\gamma }_t{\lambda }_t\pi \left(A_t|S_t\right){\mathbf{z}}_{t-1}+\nabla \hat{q}\left(S_t,A_t,{\mathbf{w}}_t\right)$

结合参数更新的规则${\mathbf{w}}_{t+1}\doteq {\mathbf{w}}_t+\alpha {\delta }_t{\mathbf{z}}_t$，我们就得到了TB($\lambda$)算法。和所有的半梯度方法一样，使用off-policy数据和拟合器时这个算法不能保证稳定，而为了保证稳定，TB($\lambda$)必须结合下一节所介绍的任一个方法。

12. 带有迹的稳定off-policy方法

目前人们已经提出了几种off-policy训练下能保证稳定的资格迹方法，这里我们给出四种比较重要的。这些方法要么基于梯度TD，要么基于Emphatic TD，所有的算法都假设使用线性拟合器，也有文献把它们扩充到非线性情形。

---

GTD($\lambda$)是类似于TDC的资格迹算法，这两种状态值梯度TD预测算法的比较在11.8节中已经讨论过了。这种算法的目标是基于on-policy或者off-policy的样本，学习到参数${\mathbf{w}}_t$，使$\hat{v}(s,\mathbf{w})\doteq {\mathbf{w}}_t^{\top }\mathbf{x}(s)\approx v_{\pi }(s)$，其更新公式为：

${\mathbf{w}}_{t+1}\doteq {\mathbf{w}}_t+\alpha {\delta }_t^s{\mathbf{z}}_t-\alpha {\gamma }_{t+1}\left(1-{\lambda }_{t+1}\right)\left({\mathbf{z}}_t^{\top }{\mathbf{v}}_t\right){\mathbf{x}}_{t+1}$

其中，参数${\delta }_t^s,{\mathbf{z}}_t,{\rho }_t$的定义和前面的定义一样，即：
${\delta }_t^s\doteq R_{t+1}+{\gamma }_{t+1}\hat{v}\left(S_{t+1},{\mathbf{w}}_t\right)-\hat{v}\left(S_t,{\mathbf{w}}_t\right)$
${\mathbf{z}}_t\doteq {\rho }_t\left({\gamma }_t{\lambda }_t{\mathbf{z}}_{t-1}+\nabla \hat{v}\left(S_t,{\mathbf{w}}_t\right)\right)$
${\rho }_t\doteq {\rho }_{t:t}=\frac{\pi \left(A_t|S_t\right)}{b\left(A_t|S_t\right)}$
而$v_t$的迭代式为：
${\mathbf{v}}_{t+1}\doteq {\mathbf{v}}_t+\beta {\delta }_t^s{\mathbf{z}}_t-\beta \left({\mathbf{v}}_t^{\top }{\mathbf{x}}_t\right){\mathbf{x}}_t$
正如11.8节中讨论的，$\mathbf{v}\in {\mathbb{R}}^d$是和参数$\mathbf{w}$维度一样的向量，且初值为0：$\mathbf{v}\in {\mathbb{R}}^d$；$\beta$是大于零的第二个步长参数。

---

GQ($\lambda$)是针对动作值的带有资格迹的梯度TD算法。其目标是基于off-policy数据，学习到参数${\mathbf{w}}_t$，使之满足：$\hat{q}\left(s,a,{\mathbf{w}}_t\right)\doteq {\mathbf{w}}_t^{\top }\mathbf{x}(s,a)\approx q_{\pi }(s,a)$。如果target策略针对贪婪策略是有偏的，那么GQ($\lambda$)可以被用作控制算法。其更新公式为：

${\mathbf{w}}_{t+1}\doteq {\mathbf{w}}_t+\alpha {\delta }_t^a{\mathbf{z}}_t-\alpha {\gamma }_{t+1}\left(1-{\lambda }_{t+1}\right)\left({\mathbf{z}}_t^{\top }{\mathbf{v}}_t\right){\overline{\mathbf{x}}}_{t+1}$

其中，${\overline{\mathbf{x}}}_t\doteq {\sum }_a\pi \left(a|S_t\right)\mathbf{x}\left(S_t,a\right)$，${\delta }_t^a\doteq R_{t+1}+{\gamma }_{t+1}{\mathbf{w}}_t^{\top }{\overline{\mathbf{x}}}_{t+1}-{\mathbf{w}}_t^{\top }{\mathbf{x}}_t$。${\mathbf{z}}_t$的定义和前面一小节一致：${\mathbf{z}}_t\doteq {\gamma }_t{\lambda }_t{\rho }_t{\mathbf{z}}_{t-1}+\nabla \hat{q}\left(S_t,A_t,{\mathbf{w}}_t\right)$。其余参数则与本节前面介绍的GTD($\lambda$)算法一致。

---

HTD($\lambda$)是混合GTD($\lambda$)和TD($\lambda$)的状态值算法。其最有吸引力的特征为：其为TD($\lambda$)在off-policy情形下的严格泛化，也就是如果behavior策略恰好与target策略一样，那么HTD($\lambda$)就变得和TD($\lambda$)完全一致，而这个特点对于GTD($\lambda$)是不成立的。这个特点很有用，因为TD($\lambda$)通常比GTD($\lambda$)要快，因为GTD($\lambda$)涉及两个步长因子。HTD($\lambda$)的定义为：

${\mathbf{w}}_{t+1}\doteq {\mathbf{w}}_t+\alpha {\delta }_t^s{\mathbf{z}}_t+\alpha \left({\left({\mathbf{z}}_t-{\mathbf{z}}_t^b\right)}^{\top }{\mathbf{v}}_t\right)\left({\mathbf{x}}_t-{\gamma }_{t+1}{\mathbf{x}}_{t+1}\right)$
${\mathbf{v}}_{t+1}\doteq {\mathbf{v}}_t+\beta {\delta }_t^s{\mathbf{z}}_t-\beta \left({\mathbf{z}}_t^{b\top }{\mathbf{v}}_t\right)\left({\mathbf{x}}_t-{\gamma }_{t+1}{\mathbf{x}}_{t+1}\right),$ with ${\mathbf{v}}_0\doteq 0$
${\mathbf{z}}_t\doteq {\rho }_t\left({\gamma }_t{\lambda }_t{\mathbf{z}}_{t-1}+{\mathbf{x}}_t\right),$ with ${\mathbf{z}}_{-1}\doteq 0$
${\mathbf{z}}_t^b\doteq {\gamma }_t{\lambda }_t{\mathbf{z}}_{t-1}^b+{\mathbf{x}}_t,$ with ${\mathbf{z}}_{-1}^b\doteq 0$

其中，$\beta$是大于零的第二个步长参数。注意这里${\mathbf{v}}_t$和${\mathbf{z}}_t^b$的定义和前面不一样，他们是behavior策略通常的accumulating资格迹，并且当${\rho }_t=1$时，${\mathbf{z}}_t^b={\mathbf{z}}_t$，使得${\mathbf{w}}_t$更新公式中的最后一项是0，因此更新公式变得和TD($\lambda$)一致。

---

Emphatic TD($\lambda$)是one-step Emphatic-TD算法引入资格迹的扩展，在off-policy下有很好的收敛保证，但是这是以较大的方差和较慢的收敛速度为代价的。其定义为：

$\begin{array}{rl}{\mathbf{w}}_{t+1}& \doteq {\mathbf{w}}_t+\alpha {\delta }_t{\mathbf{z}}_t\\ {\delta }_t& \doteq R_{t+1}+{\gamma }_{t+1}{\mathbf{w}}_t^{\top }{\mathbf{x}}_{t+1}-{\mathbf{w}}_t^{\top }{\mathbf{x}}_t\\ {\mathbf{z}}_t& \doteq {\rho }_t\left({\gamma }_t{\lambda }_t{\mathbf{z}}_{t-1}+M_t{\mathbf{x}}_t\right),\text{ with }{\mathbf{z}}_{-1}\doteq 0\\ M_t& \doteq {\lambda }_t{I}_t+\left(1-{\lambda }_t\right)F_t\\ F_t& \doteq {\rho }_{t-1}{\gamma }_t{F}_{t-1}+I_t,\text{ with }{F}_0\doteq i\left(S_0\right)\end{array}$

其中，$M_t\ge 0$，也就是所谓的emphasis，$F_t\ge 0$被称作followon迹，$I_t\ge 0$是所谓的interest。注意，$M_t$像${\delta }_t$一样，不是真正的额外记忆变量，使用资格迹的形式替换可以去掉这个变量。这个算法的真正在线版本伪代码可以在网络上查到(Sutton, 2015b)。

在on-policy情形下，Emphatic TD($\lambda$)和经典的TD($\lambda$)是相似的，但仍然有较大的不同。实际上，Emphatic TD($\lambda$)对于所有状态独立的$\lambda$函数都能保证收敛，但是TD($\lambda$)就不能保证，TD($\lambda$)只有在恒定$\lambda$时才能保证收敛性。这个可以参考(Ghiassian, Rafiee, and Sutton, 2016)。

13. 实现中的问题

对于表格化算法，使用资格迹地方法比one-step算法计算上复杂很多。最naive的实现要求在每个step都要更新估计值和资格迹，这对于单指令、多数据、并行计算机或者神经网络中都不是问题，但是对于串行计算机则问题较大。幸运的是，对于典型的$\lambda$和$\gamma$取值，几乎所有状态的资格迹都将经常是0，只有那些最近被访问的状态才有明显大于0的迹，且只有很少的状态需要更新。

实践中，通常只有那些明显大于0的迹才会被跟踪和更新，使用这个技巧，在表格方法中使用资格迹的计算代价只是one-step方法的数倍，具体则取决于参数$\lambda$和$\gamma$的取值，而表格情形是使用资格迹最差的情形。当使用拟合器时，则资格迹造成的计算提高就小很多，例如，使用ANN和反向传播算法时，资格迹只会导致存储和计算代价增加一倍(per step)，截断$\lambda$-return则在传统计算机上计算效率更高，虽然会增加一定的内存开销。

14. 总结

资格迹与TD误差结合，提供了一种高效、增量的折中TD和MC的方式。虽然第七章中的n-step方法也有这个作用，但是资格迹方法更加通用，学习速度更快，并且能够提供不同程度的计算复杂度权衡。本章给出了各种基于资格迹的算法，真正在线方法在保证和TD方法类似的计算复杂度的同时，达到了那些需要更多计算的方法的性能；另一类则是增量backward-view算法。

正如我们第五章提到的，MC方法在非马尔可夫任务中可能有优势，因为它不需要bootstrap。而资格迹方法使得TD方法接近于MC方法，从而在这种场景中也能表现得较好。如果我们既需要TD的某些优点，任务本身又带有一定的非马尔可夫性，那么资格迹方法就是好的选择。资格迹方法是长期延迟回报和非马尔可夫任务的第一道防线。

通过调整$\lambda$，我们可以在MC和one-step TD之间平滑移动，得到一系列新的方法。那么如何设置这个参数呢？目前还没有理论上的指导，但是经验上的指导还是有的。对于每个episode有很多steps的任务，或者折扣的半衰期覆盖很多steps的任务，使用资格迹效果会很好，如下图。另一方面，如果使用资格迹时使之过于接近MC方法($\lambda$接近1.0)，那么性能会快速下降。因此，选择折中的参数是效果最好的，资格迹方法应该让我们的方法向MC靠近，但是不能太近。

使用资格迹的方法比one-step方法需要更多的计算，但是大大加速了学习，特别是当reward延迟了很多步的时候。因此，当数据是稀疏的或者难以重复处理时(在线应用)，使用资格迹是很有价值的。另一方面，在离线应用中，数据可以廉价地大量产生，此时使用资格迹就不合适了，因为这时需要尽可能快的处理大量数据。

参考文献

[1].(张文博客)https://zhuanlan.zhihu.com/c_1060499676423471104