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
1263
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
