首页 > 其他分享> > ADPRL - 近似动态规划和强化学习 - Note 11 - 时序差分学习(Theory of TD learning)

ADPRL - 近似动态规划和强化学习 - Note 11 - 时序差分学习(Theory of TD learning)

2022-01-26 19:59:42 作者：互联网

Note 11 - 时序差分学习(Theory of TD learning)

时序差分学习

Note 11 - 时序差分学习(Theory of TD learning)

在上个Note中，我们重温了RL的基础概念，即TD学习和它的扩展与资格迹。由于TD算法的简单性和突出的性能，用线性函数近似法（LFA）对TD机制的扩展肯定对解决维度诅咒有很大优点。

让我们回顾一个典型的线性方程近似（LFA）： J = Φ ⊤ h ∈ R K J=\Phi^{\top} h \in \mathbb{R}^{K} J=Φ⊤h∈RK，并有 Φ : = [ ϕ 1 , … , ϕ K ] ∈ R m × K \Phi:=\left[\phi_{1}, \ldots, \phi_{K}\right] \in \mathbb{R}^{m \times K} Φ:=[ϕ1,…,ϕK]∈Rm×K。如果把TD误差 δ ( x , u , x ′ ) \delta\left(x, u, x^{\prime}\right) δ(x,u,x′)看作是描述转换 ( x , u , x ′ ) \left(x, u, x^{\prime}\right) (x,u,x′)的信息，经典的TD更新与LFA可以构造为

h k + 1 = h k + α k ( g ( x k , u k , x k ′ ) + γ h k ⊤ ϕ ( x k ′ ) − h k ⊤ ϕ ( x k ) ) ϕ ( x k ) (11.1) h_{k+1}=h_{k}+\alpha_{k}\left(g\left(x_{k}, u_{k}, x_{k}^{\prime}\right)+\gamma h_{k}^{\top} \phi\left(x_{k}^{\prime}\right)-h_{k}^{\top} \phi\left(x_{k}\right)\right) \phi\left(x_{k}\right) \tag{11.1} hk+1=hk+αk(g(xk,uk,xk′)+γhk⊤ϕ(xk′)−hk⊤ϕ(xk))ϕ(xk)(11.1)

这个更新是在每个转换 ( x , u , x ′ ) \left(x, u, x^{\prime}\right) (x,u,x′)之后触发的。注意，经典的TD更新修订了每个单独状态下的总成本的近似值，而带LFA的TD更新了权重向量，即隐含了每个时间的整个总成本近似。有一个明显的惊喜，与更新规则（11.1）相关的算法可以被证明是渐进地收敛于投影贝尔曼算子的固定点，如Proposition 8.6所示。

第一个关于LFA的TD学习理论是作为梯度下降算法的一些变体而提出的。然而，这些TD学习算法被认为不是真正的梯度下降算法作为后续，关于传统TD学习算法的收敛性和鲁棒性的尝试理论被削弱和限制。虽然最近尝试用半梯度的概念来重新解释TD的概念，但对TD学习的简明解释仍然有些欠缺。在这一章中，我们旨在揭示TD学习算法的数学基础，以及对收敛特性的简明解读，与自举（bootstrapping ）的概念形成对比，自举是一种用来近似总成本的挥手技巧（hand-waving trick）。

11.1 随机近似算法简述（Stochastic Approximation Algorithm in Nutshell）

在本小节中，我们回顾了随机逼近（Stochastic Approximation， SA）理论中的一些基本结果，以便我们能够更好地理解带有LFA的经典TD学习算法。具体来说，SA算法的目的是找到一些非线性自映射 z : R m → R m z: \mathbb{R}^{m} \rightarrow \mathbb{R}^{m} z:Rm→Rm的根，即，对 h ∈ R m h\in \mathbb{R}^{m} h∈Rm解决以下方程

z ( h ) = 0. (11.2) z(h)=0 . \tag{11.2} z(h)=0.(11.2)

这里，自映射 z z z通常被假定为在其参数 h h h中是连续的。SA算法处理的是一种非常有趣和具有挑战性的情况，即函数 z z z是未知的，只有 z z z的一些 "噪声测量 "可以获得。特别是，噪声测量被建模为

y = z ( h ) + w (11.3) y=z(h)+w \tag{11.3} y=z(h)+w(11.3)

其中 w w w是一个零平均的随机变量，代表噪音，其概率密度函数为 p （ w ） p（w） p（w）。显然，对于一个固定的 h h h， y y y是一个随机变量，其期望值等于 z ( h ) z(h) z(h)，即：

E p ( y ) [ y ] = E p ( w ) [ z ( h ) + w ] = z ( h ) , (11.4) \mathbb{E}_{p(y)}[y]=\mathbb{E}_{p(w)}[z(h)+w]=z(h), \tag{11.4} Ep(y)[y]=Ep(w)[z(h)+w]=z(h),(11.4)

其中 p ( y ) p(y) p(y)表示噪声测量的概率密度函数。经典的SA算法迭代了以下更新规则

h k + 1 = h k + α k y k , (11.5) h_{k+1}=h_{k}+\alpha_{k} y_{k}, \tag{11.5} hk+1=hk+αkyk,(11.5)
其中 y k y_{k} yk 是函数 z z z的噪声度量。在一些适当的条件下，SA算法会收敛到 z ( h ) z(h) z(h)的根。

SA的一个特别有趣的变化涉及到固定点算法。让 T : R K → R K \mathbf{T}: \mathbb{R}^{K} \rightarrow \mathbb{R}^{K} T:RK→RK 是 R K \mathbb{R}^{K} RK上的一个收缩，有一个唯一的固定点，即 T ( h ) = h \mathrm{T}(h)=h T(h)=h。 T \mathrm{T} T的唯一固定点可以被描述为以下自映射的根

z T ( h ) : = T ( h ) − h . (11.6) z_{\mathrm{T}}(h):=\mathrm{T}(h)-h . \tag{11.6} zT(h):=T(h)−h.(11.6)

同样地，当收缩 T \mathbf{T} T被假定为不可获得时，有一些 “噪音测量”
y T = z T ( h ) + w , (11.7) y_{\mathrm{T}}=z_{\mathrm{T}}(h)+w, \tag{11.7} yT=zT(h)+w,(11.7)

我们最终得到以下SA算法
h k + 1 = h k + α k y T ( k ) (11.8) h_{k+1}=h_{k}+\alpha_{k} y_{\mathrm{T}}^{(k)} \tag{11.8} hk+1=hk+αkyT(k)(11.8)

其中 y T ( k ) y_{\mathrm{T}}^{(k)} yT(k)是函数 z T z_{\mathrm{T}} zT的噪声测量。

11.1.1 用线性方程近似来理解TD

让我们回顾一下，对于一个给定的策略 π \pi π，投影贝尔曼算子的固定点属性为
Φ ⊤ h = Π π T π Φ ⊤ h . (11.9) \Phi^{\top} h=\Pi_{\pi} \mathrm{T}_{\pi} \Phi^{\top} h . \tag{11.9} Φ⊤h=ΠπTπΦ⊤h.(11.9)

由于特征矩阵 Φ ∈ R m × K \Phi \in \mathbb{R}^{m \times K} Φ∈Rm×K被假定为具有完整的行秩，很明显，在上述方程的两边从左边乘以 Φ Ξ π \Phi \Xi_{\pi} ΦΞπ并不改变其解，即
Φ Ξ π Φ ⊤ h = Φ Ξ π Π π T π Φ ⊤ h . (11.10) \Phi \Xi_{\pi} \Phi^{\top} h=\Phi \Xi_{\pi} \Pi_{\pi} \mathrm{T}_{\pi} \Phi^{\top} h . \tag{11.10} ΦΞπΦ⊤h=ΦΞπΠπTπΦ⊤h.(11.10)

让我们回顾一下投影的定义
Π π ( J ) : = Φ ⊤ ( Φ Ξ π Φ ⊤ ) − 1 Φ Ξ π J , (11.11) \Pi_{\pi}(J):=\Phi^{\top}\left(\Phi \Xi_{\pi} \Phi^{\top}\right)^{-1} \Phi \Xi_{\pi} J, \tag{11.11} Ππ(J):=Φ⊤(ΦΞπΦ⊤)−1ΦΞπJ,(11.11)

然后我们得到
Φ Ξ π Φ ⊤ h = Φ Ξ π T π Φ ⊤ h , (11.12) \Phi \Xi_{\pi} \Phi^{\top} h=\Phi \Xi_{\pi} \mathrm{T}_{\pi} \Phi^{\top} h, \tag{11.12} ΦΞπΦ⊤h=ΦΞπTπΦ⊤h,(11.12)

并定义以下自映射的寻根问题
z 0 ( h ) : R m → R m z 0 ( h ) : = Φ Ξ π T π Φ ⊤ h − Φ Ξ π Φ ⊤ h . (11.13) \begin{aligned} z_{0}(h): \mathbb{R}^{m} & \rightarrow \mathbb{R}^{m} \\ z_{0}(h) &:=\Phi \Xi_{\pi} \mathrm{T}_{\pi} \Phi^{\top} h-\Phi \Xi_{\pi} \Phi^{\top} h . \end{aligned} \tag{11.13} z0(h):Rmz0(h)→Rm:=ΦΞπTπΦ⊤h−ΦΞπΦ⊤h.(11.13)

更具体地说，自映射 z T π z_{\mathrm{T}_{\pi}} zTπ的计算方法是
z 0 ( h ) : = E p π ( x ′ ∣ x ) [ ( g ( x , u , x ′ ) + γ h ⊤ ϕ ( x ′ ) − h ⊤ ϕ ( x ) ) ϕ ( x ) ] . (11.14) z_{0}(h):=\mathbb{E}_{p_{\pi}\left(x^{\prime} \mid x\right)}\left[\left(g\left(x, u, x^{\prime}\right)+\gamma h^{\top} \phi\left(x^{\prime}\right)-h^{\top} \phi(x)\right) \phi(x)\right] . \tag{11.14} z0(h):=Epπ(x′∣x)[(g(x,u,x′)+γh⊤ϕ(x′)−h⊤ϕ(x))ϕ(x)].(11.14)

一个解决寻根问题的SA算法 z T π ( h ) z_{\mathrm{T}_{\pi}}(h) zTπ(h)给出如下
h k + 1 = h k + α k ( g ( x k , u k , x k ′ ) + γ h k ⊤ ϕ ( x k ′ ) − h k ⊤ ϕ ( x k ) ) ϕ ( x k ) , (11.15) h_{k+1}=h_{k}+\alpha_{k}\left(g\left(x_{k}, u_{k}, x_{k}^{\prime}\right)+\gamma h_{k}^{\top} \phi\left(x_{k}^{\prime}\right)-h_{k}^{\top} \phi\left(x_{k}\right)\right) \phi\left(x_{k}\right), \tag{11.15} hk+1=hk+αk(g(xk,uk,xk′)+γhk⊤ϕ(xk′)−hk⊤ϕ(xk))ϕ(xk),(11.15)

这是带LFA的TD学习算法的原始形式，见算法14。

在这里插入图片描述
注意，如果 Φ = I K \Phi=I_{K} Φ=IK，即特征矩阵是 K K K维的单位矩阵，那么公式（11.1）中的更新规则就可以简单地归结为经典的TD ( 0 ) (0) (0)算法。最后，带LFA的 T D ( 0 ) \mathrm{TD}(0) TD(0)学习算法的收敛特性直接来自SA的收敛理论。更多的细节和讨论将在第11.2节给出。

Theorem 11.1 TD ⁡ ( 0 ) \operatorname{TD}(0) TD(0)与LFA的收敛性 (Convergence of TD ⁡ ( 0 ) \operatorname{TD}(0) TD(0) with LFA)

给出一个无限范围的MDP { X , U , p , g , γ } \{\mathcal{X}, \mathcal{U}, p, g, \gamma\} {X,U,p,g,γ}，并让步长 α k \alpha_{k} αk满足Robbins-Monro条件。那么，由带LFA的TD ( 0 ) (0) (0)学习算法产生的向量 h k h_{k} hk以1的概率收敛于投影贝尔曼算子的固定点。

11.1.2 带有线性方程近似的资格迹

作为LFA的一个有趣的副作用，TD ( 0 ) (0) (0)学习算法有更好的机会来避免更新的局部性，因为权重向量 h h h对所有状态都是普遍更新的。在本小节中，我们旨在将资格迹的概念扩展到LFA。让我们回顾一下公式（5.10）中定义的 λ \lambda λ-几何平均贝尔曼算子，我们给出以下结果，无需证明。

Proposition 11.1

给出一个无限范围的 M D P { X , U , p , g , γ } M D P\{\mathcal{X}, \mathcal{U}, p, g, \gamma\} MDP{X,U,p,g,γ}，以及一个固定的策略 π \pi π。投射的 λ \lambda λ几何平均贝尔曼算子 Π π ∘ T π , λ ∞ \Pi_{\pi} \circ \mathrm{T}_{\pi, \lambda}^{\infty} Ππ∘Tπ,λ∞是模块 γ ( 1 − λ ) 1 − λ γ \frac{\gamma(1-\lambda)}{1-\lambda \gamma} 1−λγγ(1−λ)相对于 ξ \xi ξ加权范数的收缩。

我们应用与第11.1节相同的技巧来构造以下的寻根问题
z λ ( h ) : = Φ Ξ T π , λ ∞ Φ ⊤ h − Φ Ξ Φ ⊤ h = 0 (11.16) z_{\lambda}(h):=\Phi \Xi T_{\pi, \lambda}^{\infty} \Phi^{\top} h-\Phi \Xi \Phi^{\top} h=0 \tag{11.16} zλ(h):=ΦΞTπ,λ∞Φ⊤h−ΦΞΦ⊤h=0(11.16)

经验平均数的计算导致了
Φ Ξ T π , λ ∞ Φ ⊤ h − Φ Ξ Φ ⊤ h ≈ 1 k + 1 ∑ t = 0 k ϕ ( x t ) ∑ m = t k γ m − t λ m − t δ ( x m , u m , x m + 1 ) = 1 k + 1 ∑ t = 0 k ∑ m = t k γ m − t λ m − t ϕ ( x t ) δ ( x m , u m , x m + 1 ) = 1 k + 1 ∑ m = 0 k ∑ t = 0 m γ m − t λ m − t ϕ ( x t ) δ ( x m , u m , x m + 1 ) = 1 k + 1 ∑ m = 0 k δ ( x m , u m , x m + 1 ) ∑ t = 0 m γ m − t λ m − t ϕ ( x t ) . (11.17) \begin{aligned} \Phi \Xi T_{\pi, \lambda}^{\infty} \Phi^{\top} h-\Phi \Xi \Phi^{\top} h & \approx \frac{1}{k+1} \sum_{t=0}^{k} \phi\left(x_{t}\right) \sum_{m=t}^{k} \gamma^{m-t} \lambda^{m-t} \delta\left(x_{m}, u_{m}, x_{m+1}\right) \\ &=\frac{1}{k+1} \sum_{t=0}^{k} \sum_{m=t}^{k} \gamma^{m-t} \lambda^{m-t} \phi\left(x_{t}\right) \delta\left(x_{m}, u_{m}, x_{m+1}\right) \\ &=\frac{1}{k+1} \sum_{m=0}^{k} \sum_{t=0}^{m} \gamma^{m-t} \lambda^{m-t} \phi\left(x_{t}\right) \delta\left(x_{m}, u_{m}, x_{m+1}\right) \\ &=\frac{1}{k+1} \sum_{m=0}^{k} \delta\left(x_{m}, u_{m}, x_{m+1}\right) \sum_{t=0}^{m} \gamma^{m-t} \lambda^{m-t} \phi\left(x_{t}\right) . \end{aligned} \tag{11.17} ΦΞTπ,λ∞Φ⊤h−ΦΞΦ⊤h≈k+11t=0∑kϕ(xt)m=t∑kγm−tλm−tδ(xm,um,xm+1)=k+11t=0∑km=t∑kγm−tλm−tϕ(xt)δ(xm,um,xm+1)=k+11m=0∑kt=0∑mγm−tλm−tϕ(xt)δ(xm,um,xm+1)=k+11m=0∑kδ(xm,um,xm+1)t=0∑mγm−tλm−tϕ(xt).(11.17)

这里的诀窍是，计算总和时要用 0 ≤ t ≤ m ≤ k . 0\leq t\leq m\leq k. 0≤t≤m≤k.，显然，第三个总和与第二个总和是完全相同的数量，但样本的枚举不同。让指数 k k k变成无穷大。那么很明显，对于每个采样段，向量
ε = lim ⁡ m → ∞ ∑ t = 0 m γ m − t λ m − t ϕ ( x t ) (11.18) \varepsilon=\lim _{m \rightarrow \infty} \sum_{t=0}^{m} \gamma^{m-t} \lambda^{m-t} \phi\left(x_{t}\right) \tag{11.18} ε=m→∞limt=0∑mγm−tλm−tϕ(xt)(11.18)

与所访问的状态无关，但只与时间有关。很容易看出，特征的总和可以用样本，即资格迹向量有效地计算出来。显然，在互动进行时，资格迹是打折的特征向量之和。因此，我们定义

ϵ k + 1 : = ϕ ( x k ) + λ γ ϵ k . (11.19) \epsilon_{k+1}:=\phi\left(x_{k}\right)+\lambda \gamma \epsilon_{k} . \tag{11.19} ϵk+1:=ϕ(xk)+λγϵk.(11.19)
因此，使用LFA的 TD ⁡ ( λ ) \operatorname{TD}(\lambda) TD(λ)学习更新被给出为

h k + 1 = h k + α k ( g ( x k , u k , x k ′ ) + γ h k ⊤ ϕ ( x k ′ ) − h k ⊤ ϕ ( x k ) ) ϵ k + 1 . (11.20) h_{k+1}=h_{k}+\alpha_{k}\left(g\left(x_{k}, u_{k}, x_{k}^{\prime}\right)+\gamma h_{k}^{\top} \phi\left(x_{k}^{\prime}\right)-h_{k}^{\top} \phi\left(x_{k}\right)\right) \epsilon_{k+1} . \tag{11.20} hk+1=hk+αk(g(xk,uk,xk′)+γhk⊤ϕ(xk′)−hk⊤ϕ(xk))ϵk+1.(11.20)

关于算法的更多细节在算法15中给出。
在这里插入图片描述

如果 λ = 0 \lambda=0 λ=0，用LFA的 TD ⁡ ( λ ) \operatorname{TD}(\lambda) TD(λ)学习更新就简单地退化为经典的 T D ( 0 ) \mathrm{TD}(0) TD(0)更新，如公式（11.1）。最后，我们在下面的proposition中提出了经典收敛特性。

Theorem 11.2 T D ( λ ) \mathrm{TD}(\lambda) TD(λ)的收敛性与LFA (Convergence of T D ( λ ) \mathrm{TD}(\lambda) TD(λ) with LFA)

给出一个无限范围的 M D P { X , U , p , g , γ } M D P\{\mathcal{X}, \mathcal{U}, p, g, \gamma\} MDP{X,U,p,g,γ}，以及一个固定的策略 π \pi π。让步长 α k \alpha_{k} αk满足Robbins-Monro条件。然后，由 T D ( λ ) T D(\lambda) TD(λ)精益算法产生的矢量 h k h_{k} hk在 L F A L F A LFA的情况下收敛于投影 λ \lambda λ-几何平均Bellman算子的固定点 Π π ∘ T π , λ ∞ \Pi_{\pi} \circ \mathrm{T}_{\pi, \lambda}^{\infty} Ππ∘Tπ,λ∞ 的概率为1。

11.2 TD学习的收敛性（Convergence of TD Learning）

在上一章中，我们介绍了TD学习的概念及其对资格迹的扩展，即多步TD学习。尽管这种发展的背后是启发式的，但所有这些算法最终都被证明是渐进地收敛于它们的期望解。在分析TD算法的收敛特性方面的主要发展是基于随机近似理论，这最初是由Robbins和Monro提出的。在这一节中，我们提出了一个通用框架，该框架已经开发出来，可以用来研究TD学习算法系列的收敛特性。

我们采用一种随机过程的形式，以及它的收敛特性。具体来说，我们关注有限集 X \mathcal{X} X上的随机迭代过程，构造如下
Δ k + 1 ( x ) = ( 1 − α k ( x ) ) Δ k ( x ) + α k ( x ) R k ( x ) (11.21) \Delta_{k+1}(x)=\left(1-\alpha_{k}(x)\right) \Delta_{k}(x)+\alpha_{k}(x) R_{k}(x) \tag{11.21} Δk+1(x)=(1−αk(x))Δk(x)+αk(x)Rk(x)(11.21)

其中， x ∈ X x\in \mathcal{X} x∈X中， Δ k + 1 ( x ) ∈ R m \Delta_{k+1}(x)\in \mathbb{R}^{m} Δk+1(x)∈Rm。让我们定义

R k = { x 1 , α 1 ( x 1 ) , R 1 ( x 1 ) , … , x k , α 1 ( x k ) } (11.22) \mathcal{R}_{k}=\left\{x_{1}, \alpha_{1}\left(x_{1}\right), R_{1}\left(x_{1}\right), \ldots, x_{k}, \alpha_{1}\left(x_{k}\right)\right\} \tag{11.22} Rk={x1,α1(x1),R1(x1),…,xk,α1(xk)}(11.22)

作为截至步骤 k k k的随机迭代过程的历史。该随机迭代过程的收敛特性在以下定理中给出。

Theorem 11.3

在以下假设下，公式（11.21）中定义的随机迭代过程以概率1收敛到零。
(1) ∑ k = 1 ∞ α k ( x ) = ∞ \sum_{k=1}^{\infty} \alpha_{k}(x)=\infty ∑k=1∞αk(x)=∞, and ∑ k = 1 ∞ ( α k ( x ) ) 2 < ∞ \sum_{k=1}^{\infty}\left(\alpha_{k}(x)\right)^{2}<\infty ∑k=1∞(αk(x))2<∞

(2) ∥ E [ R k ( x ) ∣ R k ] ∥ W ≤ γ ∥ Δ k ∥ W \left\|\mathbb{E}\left[R_{k}(x) \mid \mathcal{R}_{k}\right]\right\|_{W} \leq \gamma\left\|\Delta_{k}\right\|_{W} ∥E[Rk(x)∣Rk]∥W≤γ∥Δk∥W with γ < 1 \gamma<1 γ<1

(3) var ⁡ [ R k ( x ) ∣ R k ] ≤ C ( 1 + ∥ Δ k ∥ W 2 ) \operatorname{var}\left[R_{k}(x) \mid \mathcal{R}_{k}\right] \leq C\left(1+\left\|\Delta_{k}\right\|_{W}^{2}\right) var[Rk(x)∣Rk]≤C(1+∥Δk∥W2) with C > 0 C>0 C>0

这里， ∥ Δ k ∥ W \left\|\Delta_{k}\right\|_{W} ∥Δk∥W表示一些适当的范数。

Remark 11.1. 这个结果可以应用于大多数同时具有表格特征或LFA的TD学习算法。在本节的其余部分，我们将证明该定理以显示 Q Q Q学习算法的渐进收敛特性。

简而言之，算法12中所示的 Q Q Q学习算法的渐进收敛特性在以下命题中给出。

Proposition 11.2

给定一个无限范围的MDP { X , U , p , g , γ } \{\mathcal{X}, \mathcal{U}, p, g, \gamma\} {X,U,p,g,γ}，只要学习率满足Robbins-Monro条件， Q Q Q学习算法就会收敛到最优状态-行动价值函数 Q ∗ Q^{*} Q∗。

Proof.
让我们把 Q Q Q学习算法的更新规则改写为

Q k + 1 ( x k , u k ) = ( 1 − α k ( x k , u k ) ) Q k ( x k , u k ) + α k ( x k , u k ) ( g ( x k , u k , x k ′ ) + γ min ⁡ u k ′ Q k ( x k ′ , u k ′ ) ) (11.23) \begin{aligned} Q_{k+1}\left(x_{k}, u_{k}\right)=(1-&\left.\alpha_{k}\left(x_{k}, u_{k}\right)\right) Q_{k}\left(x_{k}, u_{k}\right)+\\ & \alpha_{k}\left(x_{k}, u_{k}\right)\left(g\left(x_{k}, u_{k}, x_{k}^{\prime}\right)+\gamma \min _{u_{k}^{\prime}} Q_{k}\left(x_{k}^{\prime}, u_{k}^{\prime}\right)\right) \end{aligned} \tag{11.23} Qk+1(xk,uk)=(1−αk(xk,uk))Qk(xk,uk)+αk(xk,uk)(g(xk,uk,xk′)+γuk′minQk(xk′,uk′))(11.23)

我们从方程两边减去项 Q ∗ ( x t , u t ) Q^{*}\left(x_{t}, u_{t}\right) Q∗(xt,ut)，然后定义
Δ k ( x , u ) : = Q k ( x , u ) − Q ∗ ( x , u ) (11.24) \Delta_{k}(x, u):=Q_{k}(x, u)-Q^{*}(x, u) \tag{11.24} Δk(x,u):=Qk(x,u)−Q∗(x,u)(11.24)

与

R k ( x , u ) : = g ( x , u , x ′ ) + γ min ⁡ u ′ Q k ( x ′ , u ′ ) − Q ∗ ( x , u ) (11.25) R_{k}(x, u):=g\left(x, u, x^{\prime}\right)+\gamma \min _{u^{\prime}} Q_{k}\left(x^{\prime}, u^{\prime}\right)-Q^{*}(x, u) \tag{11.25} Rk(x,u):=g(x,u,x′)+γu′minQk(x′,u′)−Q∗(x,u)(11.25)

显然，我们有

Δ k + 1 ( x k , u k ) = ( 1 − α k ( x k , u k ) ) Δ k ( x k , u k ) + α k ( x k , u k ) R k ( x k , u k ) (11.26) \Delta_{k+1}\left(x_{k}, u_{k}\right)=\left(1-\alpha_{k}\left(x_{k}, u_{k}\right)\right) \Delta_{k}\left(x_{k}, u_{k}\right)+\alpha_{k}\left(x_{k}, u_{k}\right) R_{k}\left(x_{k}, u_{k}\right) \tag{11.26} Δk+1(xk,uk)=(1−αk(xk,uk))Δk(xk,uk)+αk(xk,uk)Rk(xk,uk)(11.26)

这正是我们感兴趣的随机迭代过程。

现在，让 x ′ ∈ X x^{\prime}\in \mathcal{X} x′∈X是一个从MDP模型中得到的随机抽样状态。然后，我们计算

E [ R k ( x , u ) ∣ R k ] = E p ( x ′ ) [ g ( x , u , x ′ ) + γ min ⁡ u ′ Q k ( x ′ , u ′ ) − Q ∗ ( x , u ) ] = H g Q k ( x , u ) − Q ∗ ( x , u ) (11.27) \begin{aligned} \mathbb{E}\left[R_{k}(x, u) \mid \mathcal{R}_{k}\right] &=\mathbb{E}_{p\left(x^{\prime}\right)}\left[g\left(x, u, x^{\prime}\right)+\gamma \min _{u^{\prime}} Q_{k}\left(x^{\prime}, u^{\prime}\right)-Q^{*}(x, u)\right] \\ &=\mathrm{H}_{\mathfrak{g}} Q_{k}(x, u)-Q^{*}(x, u) \end{aligned} \tag{11.27} E[Rk(x,u)∣Rk]=Ep(x′)[g(x,u,x′)+γu′minQk(x′,u′)−Q∗(x,u)]=HgQk(x,u)−Q∗(x,u)(11.27)

根据最优状态行动贝尔曼算子的固定点属性，即 H g Q ∗ = Q ∗ \mathrm{H}_{\mathfrak{g}} Q^{*}=Q^{*} HgQ∗=Q∗的固定点属性，我们有

∥ E [ R k ( x , u ) ∣ R k ] ∥ ∞ = ∥ H g Q k ( x , u ) − H g Q ∗ ( x , u ) ∥ ∞ ≤ ∥ H g Q k − H g Q ∗ ∥ ∞ ≤ γ ∥ Q k − Q ∗ ∥ ∞ = γ ∥ Δ k ∥ ∞ (11.28) \begin{aligned} \left\|\mathbb{E}\left[R_{k}(x, u) \mid \mathcal{R}_{k}\right]\right\|_{\infty} &=\left\|\mathrm{H}_{\mathfrak{g}} Q_{k}(x, u)-\mathrm{H}_{\mathfrak{g}} Q^{*}(x, u)\right\|_{\infty} \\ & \leq\left\|\mathrm{H}_{\mathfrak{g}} Q_{k}-\mathrm{H}_{\mathfrak{g}} Q^{*}\right\|_{\infty} \\ & \leq \gamma\left\|Q_{k}-Q^{*}\right\|_{\infty} \\ &=\gamma\left\|\Delta_{k}\right\|_{\infty} \end{aligned} \tag{11.28} ∥E[Rk(x,u)∣Rk]∥∞=∥HgQk(x,u)−HgQ∗(x,u)∥∞≤∥HgQk−HgQ∗∥∞≤γ∥Qk−Q∗∥∞=γ∥Δk∥∞(11.28)

其中满足Theorem 11.3中的条件（2）。

最后，我们得到

var ⁡ [ R k ( x , u ) ∣ R k ] = E p ( x ′ ) [ ( R k ( x , u ) − H g Q k ( x , u ) + Q ∗ ( x , u ) ) 2 ] = E p ( x ′ ) [ ( g ( x , u , x ′ ) + γ min ⁡ u ′ Q k ( x ′ , u ′ ) − H g Q k ( x , u ) ) 2 ] = var ⁡ [ g ( x , u , x ′ ) + γ min ⁡ u ′ Q k ( x ′ , u ′ ) ∣ R k ] (11.29) \begin{aligned} \operatorname{var}\left[R_{k}(x, u) \mid \mathcal{R}_{k}\right] &=\mathbb{E}_{p\left(x^{\prime}\right)}\left[\left(R_{k}(x, u)-\mathrm{H}_{\mathfrak{g}} Q_{k}(x, u)+Q^{*}(x, u)\right)^{2}\right] \\ &=\mathbb{E}_{p\left(x^{\prime}\right)}\left[\left(g\left(x, u, x^{\prime}\right)+\gamma \min _{u^{\prime}} Q_{k}\left(x^{\prime}, u^{\prime}\right)-\mathrm{H}_{\mathfrak{g}} Q_{k}(x, u)\right)^{2}\right] \\ &=\operatorname{var}\left[g\left(x, u, x^{\prime}\right)+\gamma \min _{u^{\prime}} Q_{k}\left(x^{\prime}, u^{\prime}\right) \mid \mathcal{R}_{k}\right] \end{aligned} \tag{11.29} var[Rk(x,u)∣Rk]=Ep(x′)[(Rk(x,u)−HgQk(x,u)+Q∗(x,u))2]=Ep(x′)[(g(x,u,x′)+γu′minQk(x′,u′)−HgQk(x,u))2]=var[g(x,u,x′)+γu′minQk(x′,u′)∣Rk](11.29)

由于成本 g g g和 Q Q Q函数都是有界的，定理 11.3 11.3 11.3中的条件（3）也得到满足。因此，应用定理 11.3 11.3 11.3就完成了证明。

11.3 实例: 带有资格迹的 TD ( λ ) \text{TD}(\lambda) TD(λ)

如下图所示，一个基准环境是一个有11个状态和一个障碍物的网格。智能体从左下角的 "开始 "状态出发，停在两个终端状态。
在这里插入图片描述

有四个可用的动作：上、下、左、右。每个动作都是随机的，一步的概率为0.8，两步的概率为0.2，都是期望的方向。所有转换的局部成本为0.04，终端状态的局部成本为 ± 1 ±1 ±1。

Task 1: 给定一个确定的策略，对于所有状态应用 TD ( λ ) \text{TD}(\lambda) TD(λ)。
Task 2: 给定一个随机生成的特征 Φ \Phi Φ, 对于所有状态应用带有线性方程近似的 TD ( λ ) \text{TD}(\lambda) TD(λ)。

11.3.1 TD ( λ ) \text{TD}(\lambda) TD(λ)

from operator import xor
import random
import numpy as np

class GridWorld:
    def __init__(self, width=4, height=3, obstacle=[(1,1)]):
        self.width = width
        self.height = height

        self.obstacle = obstacle
        self.terminal = [(0, width-1), (1, width-1)]  # the terminal states are always at right top

        self.row = height - 1  # the start point is always at left bottom
        self.col = 0

        # define the MDP
        self.actions = self.act_space()
        self.states = set(self.actions.keys()) | set(self.terminal)
        self.J = self.init_J()
        self.local_cost = 0.04


    def act_space(self):
        act_space = {}

        for row in range(self.height):
            for col in range(self.width):
                possible_acts = []
                if (row, col) not in self.obstacle + self.terminal:
                    if row - 1 >= 0 and (row-1, col) not in self.obstacle:
                        possible_acts.append('U')
                    if row + 1 < self.height and (row+1, col) not in self.obstacle:
                        possible_acts.append('D')
                    if col - 1 >=0 and (row, col-1) not in self.obstacle:
                        possible_acts.append('L')
                    if col + 1 < self.width and (row, col+1) not in self.obstacle:
                        possible_acts.append('R')
                    act_space[(row, col)] = possible_acts
        return act_space

    def init_J(self, init_J_value=0):
        J = {}
        for row in range(self.height):
            for col in range(self.width):
                if (row, col) not in self.obstacle + self.terminal:
                    J[(row, col)] = init_J_value
        J[self.terminal[0]] = -1  # J(x_N) = g(x_N)
        J[self.terminal[1]] = +1
        return J

    def move(self, action, deterministic=False):
        # check if legal move first
        if action in self.actions[(self.row, self.col)]:
            if action == 'U':
                # probablistic transition
                if deterministic or random.uniform(0,1) > 0.8 or (self.row-2, self.col) not in self.states:
                    self.row -= 1
                else:
                    self.row -= 2
            elif action == 'D':
                if deterministic or random.uniform(0,1) > 0.8 or (self.row+2, self.col) not in self.states:
                    self.row += 1
                else:
                    self.row += 2
            elif action == 'R':
                if deterministic or random.uniform(0,1) > 0.8 or (self.row, self.col+2) not in self.states:
                    self.col += 1
                else:
                    self.col += 2
            elif action == 'L':
                if deterministic or random.uniform(0,1) > 0.8 or (self.row, self.col-2) not in self.states:
                    self.col -= 1
                else:
                    self.col -= 2

        if (self.row, self.col) == self.terminal[0]:
            return -1
        elif (self.row, self.col) == self.terminal[1]:
            return +1
        else:
            return self.local_cost

    def set_state(self, s):
        self.row = s[0]
        self.col = s[1]

    def current_state(self):
        return (self.row, self.col)

    def game_over(self):
        return (self.row, self.col) not in self.actions

    def print_J(self):
        for row in range(self.height):
            print("---------------------------")
            for col in range(self.width):
                J = env.J.get((row, col), 0)
                if J >= 0:
                    print(" %.2f|" % J, end="")
                else:
                    print("%.2f|" % J, end="")
            print("")
        print("---------------------------")


## Task 1： TD(lambda)
# %% TD

def play_game(grid, policy):
    start_states = list(grid.actions.keys())
    start_idx = np.random.choice(len(start_states))
    grid.set_state(start_states[start_idx])

    # generate traj
    x = grid.current_state()
    traj = [(x,0)]
    while not grid.game_over():
        u = policy[x]
        g = grid.move(u)
        x = grid.current_state()
        traj.append((x, g))  # save the trajectory
    return traj

# define the constants
gamma = 0.9
alpha = 0.1
lmbda = 0.5

env = GridWorld()

policy = {
    (2, 0): 'U',
    (1, 0): 'U',
    (0, 0): 'R',
    (0, 1): 'R',
    (0, 2): 'R',
    (1, 2): 'R',
    (2, 1): 'R',
    (2, 2): 'R',
    (2, 3): 'U',
}

for _ in range(200):
    # get the random trajectory from the policy
    traj_all = play_game(env, policy)

    # updates the total cost for each state included by the trajectory
    for idx in range(len(traj_all) - 1):
        # get current state and the successive state as well as the state cost
        x, _ = traj_all[idx]
        x_, g = traj_all[idx+1]

        # Compute the TD error of the current state
        TD_err = g + gamma * env.J[x_] - env.J[x]

        # get the eligibility trace, i.e. trajectory until state x
        e_trace = traj_all[:idx+1]

        # update the total cost for each former state
        for e_idx in range(len(e_trace)):
            x_e_trace, _ = e_trace[e_idx]
            e_x = (gamma * lmbda) ** (idx - e_idx)
            env.J[x_e_trace] = env.J[x_e_trace] + alpha * e_x * TD_err

print("\nTotal cost by TD(lambda)")
env.print_J()

输出为


Total cost by TD(lambda)
---------------------------
-1.63|-1.72|-1.90|-1.00|
---------------------------
-1.29| 0.00| 1.71| 1.00|
---------------------------
-1.13|-0.51|-0.48|-0.63|
---------------------------

11.3.2 TD ( λ ) \text{TD}(\lambda) TD(λ) with LFA


## Task 2: TD(lambda) with LFA
m = 7
K = len(env.states)

Phi = np.random.rand(m, K)  # Feature matrix
h = np.random.rand(m, 1)  # weight vector

# build the state index to retrieve the corresponding feature matrix
state_idx = {}
i = 0
for key in env.states:
    state_idx[key] = i
    i += 1

# initial the world
env = GridWorld()

# TD-lambda
for _ in range(200):
    traj_all = play_game(env, policy)
    for idx in range(len(traj_all)-1):
        # get current state and the successive state as well as the state cost
        x, _ = traj_all[idx]
        x_, g = traj_all[idx+1]

        # compute TD error delta
        delta = g + gamma * h.T @ Phi[:, state_idx[x_]] - h.T @ Phi[:, state_idx[x]]

        # get the eligibility trace, i.e. trajectory until state x
        e_trace_traj = traj_all[:idx+1]
        e_vector = 0
        for e_idx in range(idx+1):
            x_idx, _ = e_trace_traj[e_idx]

            # update the eligibility vector
            e_vector = Phi[:, state_idx[x]] + lmbda * gamma * e_vector

            # update the weight
            h = h + alpha * delta[0] * e_vector.reshape(m,1)

J_pi = Phi.T @ h

for key in state_idx:
    env.J[key] = J_pi[state_idx[key]]

# reset the terminal state
env.J[(0,3)] = -1
env.J[(1,3)] = 1

print("\nTotal cost by TD lambda with LFA")
env.print_J()

输出为


Total cost by TD lambda with LFA
---------------------------
-1.79|-2.31|-2.19|-1.00|
---------------------------
-0.94| 0.00| 0.70| 1.00|
---------------------------
-0.92| 0.06|-1.36|-1.13|
---------------------------

Process finished with exit code 0

标签：11,Phi,right,Theory,self,Note,TD,lambda,left
来源： https://blog.csdn.net/qq_37266917/article/details/122660270