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

目录

  • 随机近似与随机梯度下降
    • Mean estimation
    • Robbins-Monro 算法
      • 用 Robbins-Monro 算法解释 Mean estimation
      • 用 Robbins-Monro 算法解释 Batch Gradient descent
      • 用 SGD 解释 Mean estimation
    • SGD 的一个有趣的性质
  • 时序差分方法
    • Sarsa 算法
      • 一个例子
    • Expected Sarsa 算法
    • n-step Sarsa 算法
    • Q-learning 算法
      • off-policy 和 on-policy
    • 总结

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

随机近似与随机梯度下降

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

Mean estimation

上一节 中我们已经讨论过,在 model-free 的情况下,为了求解
q π k ( s , a ) = E [ G t ∣ S t = s , A t = a ] q_{\pi_k}(s,a) = E[G_t | S_t = s, A_t =a] qπk(s,a)=E[GtSt=s,At=a]
我们需要利用 大数定律 的结论,通过大量的采样 g π k ( i ) ( s , a ) , i = 1 , 2 , 3... g^{(i)}_{\pi_k}(s,a), i = 1,2,3... gπk(i)(s,a),i=1,2,3...,来估计 q π k ( s , a ) q_{\pi_k}(s,a) qπk(s,a)
q π k ( s , a ) = 1 n ∑ i = 1 n g π k ( i ) ( s , a ) q_{\pi_k}(s,a) = \frac{1}{n} \sum_{i=1}^n g^{(i)}_{\pi_k}(s,a) qπk(s,a)=n1i=1ngπk(i)(s,a)

我们将上述问题简记为:
E ( X ) ≈ x ˉ = 1 n ∑ i = 1 n x i E(X) \approx \bar{x} = \frac{1}{n} \sum_{i=1}^n x_i E(X)xˉ=n1i=1nxi

上述式子在实际中有一个效率的问题:需要等到所有的样本 x i x_i xi 全都采集完毕才能计算。而上述式子有一个 等价 的迭代式子:
w k + 1 = w k − 1 k ( w k − x k ) w_{k+1} = w_k - \frac{1}{k} (w_k -x_k) wk+1=wkk1(wkxk)
其中 w k = 1 k − 1 ∑ i = 1 k − 1 x i w_k = \frac{1}{k-1} \sum_{i=1}^{k-1} x_i wk=k11i=1k1xi 。证明也很容易:
w k + 1 = 1 k ∑ i = 1 k x i = 1 k ( ∑ i = 1 k − 1 x i + x k ) = 1 k ( ( k − 1 ) w k + x k ) = w k − 1 k ( w k − x k ) 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) wk+1=k1i=1kxi=k1(i=1k1xi+xk)=k1((k1)wk+xk)=wkk1(wkxk)

作为上式的延展,我们提出一个更广泛使用的迭代式:
w k + 1 = w k − α k ( w k − x k ) w_{k+1} = w_k - \alpha_k (w_k -x_k) wk+1=wkαk(wkxk)

在下面的 Robbins-Monro 算法 中,我们会展示:在满足一定条件时,上式依然满足 lim ⁡ k → ∞ w k = E [ X ] \lim_{k \rightarrow \infin} w_k = E[X] limkwk=E[X]


Robbins-Monro 算法

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

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

  1. 0 < c 1 ≤ ∇ w g ( w ) ≤ c 2 , ∀ w 0 < c_1 \leq \nabla_w g(w) \leq c_2,\forall w 0<c1wg(w)c2w
    \quad
  2. ∑ k = 1 ∞ a k = ∞ \sum_{k=1}^{\infin} a_k = \infin k=1ak= 并且 ∑ k = 1 ∞ a k 2 < ∞ \sum_{k=1}^{\infin} a_k^2 < \infin k=1ak2<
    \quad
  3. E [ η k ∣ H k ] = 0 E[\eta_k|\mathcal{H}_k] = 0 E[ηkHk]=0 并且 E [ η k 2 ∣ H k ] < ∞ E[\eta_k^2|\mathcal{H}_k] < \infin E[ηk2Hk]<,其中 H k = { w k , w k − 1 , . . . } \mathcal{H}_k = \{w_k, w_{k-1}, ...\} Hk={wk,wk1,...}

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

  1. 0 < c 1 ≤ ∇ w g ( w ) ≤ c 2 , ∀ w 0 < c_1 \leq \nabla_w g(w) \leq c_2,\forall w 0<c1wg(w)c2w:前半部分 0 < c 1 ≤ ∇ w g ( w ) 0 < c_1 \leq \nabla_w g(w) 0<c1wg(w) 是要求 g ( w ) g(w) g(w) 是单调递增函数,而由于常用的场景是求解 min ⁡ w J ( w ) \min_w J(w) minwJ(w) 时,转化为求解 ∇ w J ( w ) = 0 \nabla_w J(w) = 0 wJ(w)=0,因此 0 < c 1 ≤ ∇ w 2 J ( w ) ≤ c 2 0 < c_1 \leq \nabla_w^2 J(w) \leq c_2 0<c1w2J(w)c2 即要求 J ( w ) J(w) J(w)凸函数。而后半部分 ∇ w g ( w ) ≤ c 2 \nabla_w g(w) \leq c_2 wg(w)c2 则限制了 g ( w ) g(w) g(w) 的增长率不会发散,否则会影响 w k w_k wk 的收敛性。
    \quad
    \quad
  2. ∑ k = 1 ∞ a k = ∞ \sum_{k=1}^{\infin} a_k = \infin k=1ak= 并且 ∑ k = 1 ∞ a k 2 < ∞ \sum_{k=1}^{\infin} a_k^2 < \infin k=1ak2<:这其实是希望 a k a_k ak 是一个趋于 0,但又不会过快趋于 0 的序列。要求 a k a_k ak 趋于 0 很好理解,因为 w k + 1 − w k = a k ( g ( w k ) + η k ) w_{k+1} - w_k = a_k (g(w_k) + \eta_k) wk+1wk=ak(g(wk)+ηk) 因此 a k a_k ak 趋于 0 才能保证 w k w_k wk 能收敛。那 a k a_k ak 不会过快趋于 0 有什么作用呢?由于 w k + 1 − w k = − a k ( g ( w k ) + η k ) w_{k+1} - w_k = - a_k (g(w_k) + \eta_k) wk+1wk=ak(g(wk)+ηk),因此 w 1 − w ∞ = ∑ k = 1 ∞ a k ( g ( w k ) + η k ) w_1 - w_{\infin} = \sum_{k=1}^{\infin} a_k (g(w_k) + \eta_k) w1w=k=1ak(g(wk)+ηk),如果 a k a_k ak 很快就趋于 0 了,由于 ∇ w g ( w ) ≤ c 2 \nabla_w g(w) \leq c_2 wg(w)c2 ,因此 ∑ k = 1 ∞ a k ( g ( w k ) + η k ) \sum_{k=1}^{\infin} a_k (g(w_k) + \eta_k) k=1ak(g(wk)+ηk) 有上界,即 ∣ w 1 − w ∞ ∣ ≤ b |w_1 - w_{\infin}| \leq b w1wb 由此带来的问题是 w 1 w_1 w1 不能任意选择,因为若选的 w 1 w_1 w1 w ∗ w^* w 太远,那么 ∣ w 1 − w ∞ ∣ ≤ b |w_1 - w_{\infin}| \leq b w1wb 就不成立了,因而是否能收敛到 w ∗ w^* w 也无法保证 (NOTE: a k = 1 k a_k = \frac{1}{k} ak=k1 就是一个满足条件的例子)
    \quad
    \quad
  3. E [ η k ∣ H k ] = 0 E[\eta_k|\mathcal{H}_k] = 0 E[ηkHk]=0 并且 E [ η k 2 ∣ H k ] < ∞ E[\eta_k^2|\mathcal{H}_k] < \infin E[ηk2Hk]<:这个条件比较弱,甚至不要求 η \eta η 满足高斯分布,只要 { η k } \{\eta_k\} {ηk} 独立同分布,且满足 E [ η k ] = 0 , E [ η k 2 ] < ∞ E[\eta_k] = 0, E[\eta_k^2] < \infin E[ηk]=0E[ηk2]< 即可。本质是希望 η \eta η 中不要包含有效信息,有效的信息应该都包含在 g ( w ) g(w) g(w) 中。

抛开上述条件,Robbins-Monro 算法的想法也很简单,就是:对于一个单调递增函数,随便取一个点 w 1 w_1 w1,如果 g ( w 1 ) + η 1 < 0 g(w_1) + \eta_1 < 0 g(w1)+η1<0,说明 w ∗ w^* w w 1 w_1 w1的右边,那么下一步应该往右走,而 w 2 = w 1 − a 1 ( g ( w 1 ) + η 1 ) w_{2} = w_1 - a_1 (g(w_1) + \eta_1) w2=w1a1(g(w1)+η1)
由于 g ( w 1 ) + η 1 < 0 g(w_1) + \eta_1 < 0 g(w1)+η1<0,因此 − a 1 ( g ( w 1 ) + η 1 ) > 0 - a_1 (g(w_1) + \eta_1) > 0 a1(g(w1)+η1)>0,即方向向右。同理,如果 g ( w 1 ) + η 1 > 0 g(w_1) + \eta_1 > 0 g(w1)+η1>0,则下一步会往左走一点

图示:

用 Robbins-Monro 算法解释 Mean estimation

为了能将 Mean estimation 囊括到 Robbins-Monro 的框架下,我们需要定义: g ( w ) = w − E [ X ] g(w) = w - E[X] g(w)=wE[X]
这样求解 g ( w ∗ ) = 0 g(w^*) = 0 g(w)=0 就等价于求解 w ∗ = E [ X ] w^* = E[X] w=E[X]。由此 Robbins-Monro 中的迭代式 w k + 1 = w k − a k ( g ( w k ) + η k ) w_{k+1} = w_k - a_k (g(w_k) + \eta_k) wk+1=wkak(g(wk)+ηk)
其中 g ( w k ) = w k − E [ X ] g(w_k) = w_k - E[X] g(wk)=wkE[X] η k \eta_k ηk 是样本 x k x_k xk 的观测误差 E [ X ] − x k E[X] - x_k E[X]xk(易证 E [ η k ] = 0 E[\eta_k] = 0 E[ηk]=0 E [ η k 2 ] < ∞ E[\eta_k^2] < \infin E[ηk2]<),再取 a k = 1 k a_k = \frac{1}{k} ak=k1,因此有
w k + 1 = w k − a k ( g ( w k ) + η k ) = w k − 1 k ( w k − E [ X ] + E [ X ] − x k ) = w k − 1 k ( w k − x k ) \begin{aligned} 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{aligned} wk+1=wkak(g(wk)+ηk)=wkk1(wkE[X]+E[X]xk)=wkk1(wkxk)
Mean estimation


用 Robbins-Monro 算法解释 Batch Gradient descent

机器学习中常用的 Gradient descent 算法描述如下:
min ⁡ w J ( w ) = E [ f ( w , X ) ] \min_w J(w) = E[f(w,X)] wminJ(w)=E[f(w,X)]
其中 f f f 即损失函数, w w w 是模型中的待优化参数。求解的迭代式是:
w k + 1 = w k − α k ∇ w J ( w ) = w k − α k E [ ∇ w f ( w k , X ) ] = w k − α k ⋅ 1 n ∑ i = 1 n ∇ w f ( w k , x i ) \begin{aligned} 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{aligned} wk+1===wkαkwJ(w)wkαkE[wf(wk,X)]wkαkn1i=1nwf(wk,xi)

其中 ( x i , f ( w k , x i ) ) (x_i, f(w_k,x_i)) (xi,f(wk,xi)) 即一对样本。由于每次更新 w w w 都需要将所有的样本都计算到,因此也叫 Batch Gradient descent。 但跟 Mean estimation 类似,Batch Gradient descent 要求所有样本采样完毕才能计算,效率比较低。因此提出了每次只使用一个样本来更新参数的算法:Stochastic Gradient Descent (SGD
w k + 1 = w k − α k ∇ w f ( w k , x k ) w_{k+1} = w_k - \alpha_k \nabla_w f(w_k,x_k) wk+1=wkαkwf(wk,xk)

为了将 SGD 囊括到Robbins-Monro 的框架下,只需要定义 g ( w ) = ∇ w J ( w ) g(w) = \nabla_w J(w) g(w)=wJ(w)
那么求解 g ( w ∗ ) = ∇ w J ( w ∗ ) = 0 g(w^*) = \nabla_w J(w^*) = 0 g(w)=wJ(w)=0 就等价于求解 min ⁡ w J ( w ) \min_w J(w) minwJ(w) (当 J ( w ) J(w) J(w) 是凸函数时),可以推导:
w k + 1 = w k − a k ( g ( w k ) + η k ) = w k − α k ( E [ ∇ w f ( w k , X ) ] + ( ∇ w f ( w k , x k ) − E [ ∇ w f ( w k , X ) ] ) ) = w k − α k ⋅ ∇ w f ( w k , x k ) \begin{aligned} 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{aligned} wk+1===wkak(g(wk)+ηk)wkαk(E[wf(wk,X)]+(wf(wk,xk)E[wf(wk,X)]))wkαkwf(wk,xk)

SGD。上式中 η k = ∇ w f ( w k , x k ) − E [ ∇ w f ( w k , X ) ] \eta_k = \nabla_w f(w_k,x_k) - E[\nabla_w f(w_k,X)] ηk=wf(wk,xk)E[wf(wk,X)],同样易证 E [ η k ] = 0 E[\eta_k] = 0 E[ηk]=0 E [ η k 2 ] < ∞ E[\eta_k^2] < \infin E[ηk2]<。这里同时也说明了 SGD的收敛性,跟随 Robbins-Monro 框架的收敛性而成立


用 SGD 解释 Mean estimation

注意到如果想将 Mean estimation 套入 SGD 的框架,需要找到一个 f ( w , X ) f(w,X) f(w,X) 使得满足:
∇ w f ( w , X ) = w − X \nabla_w f(w,X) = w - X wf(w,X)=wX
因为这样就有:
w k + 1 = w k − α k ⋅ ∇ w f ( w k , x k ) = w k − α k ( w k − x k ) w_{k+1} = w_k - \alpha_k \cdot \nabla_w f(w_k,x_k) = w_k - \alpha_k (w_k - x_k) wk+1=wkαkwf(wk,xk)=wkαk(wkxk)
上式即 Mean estimation 的迭代式。因此我们可以构造:
min ⁡ w J ( w ) = E [ 1 2 ∣ ∣ w − X ∣ ∣ 2 ] \min_w J(w) = E[\frac{1}{2}||w-X||^2] wminJ(w)=E[21∣∣wX2]

这个从直观也比较好理解, 即求解 w = E [ X ] w = E[X] w=E[X] 等价于求解 min ⁡ w E [ 1 2 ∣ ∣ w − X ∣ ∣ 2 ] \min_w E[\frac{1}{2}||w-X||^2] minwE[21∣∣wX2]


SGD 的一个有趣的性质

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

w k w_k wk 距离 w ∗ w^* w 较远时,SGD 向 w ∗ w^* w 靠近的速度与一般的 GD 差不多,但是当 w k w_k wk w ∗ w^* w 比较近时,其收敛会呈现一定的 随机性

定义 δ k = ∣ ∇ w f ( w k , x k ) − E [ ∇ w f ( w k , X ) ] ∣ ∣ E [ ∇ w f ( w k , X ) ] ∣ \delta_k = \frac{|\nabla_wf(w_k,x_k) - E[\nabla_w f(w_k,X)]|}{|E[\nabla_w f(w_k,X)]|} δk=E[wf(wk,X)]wf(wk,xk)E[wf(wk,X)]
来描述 SGD 和 GD 算法的相对误差, δ k \delta_k δk 越小,表明 SGD 与 GD 的收敛速度越接近。

由于 g ( w ∗ ) = ∇ w J ( w ∗ ) = E [ ∇ w f ( w ∗ , X ) ] = 0 g(w^*) = \nabla_w J(w^*) = E[\nabla_w f(w^*,X)] = 0 g(w)=wJ(w)=E[wf(w,X)]=0,因此
δ k = ∣ ∇ w f ( w k , x k ) − E [ ∇ w f ( w k , X ) ] ∣ ∣ E [ ∇ w f ( w k , X ) ] − E [ ∇ w f ( w ∗ , X ) ] ∣ = ∣ ∇ w f ( w k , x k ) − E [ ∇ w f ( w k , X ) ] ∣ E [ ∇ w 2 f ( w k ^ , X ) ( w k − w ∗ ) ] \delta_k = \frac{|\nabla_wf(w_k,x_k) - E[\nabla_w f(w_k,X)]|}{|E[\nabla_w f(w_k,X)] - E[\nabla_w f(w^*,X)]|} = \frac{|\nabla_wf(w_k,x_k) - E[\nabla_w f(w_k,X)]|}{E[\nabla^2_w f(\hat{w_k},X)(w_k - w^*)]} δk=E[wf(wk,X)]E[wf(w,X)]wf(wk,xk)E[wf(wk,X)]=E[w2f(wk^,X)(wkw)]wf(wk,xk)E[wf(wk,X)]

其中总存在 w k ^ ∈ ( w k , w ∗ ) \hat{w_k} \in (w_k,w^*) wk^(wk,w) ,使得 E [ ∇ w f ( w k , X ) ] − E [ ∇ w f ( w ∗ , X ) ] = E [ ∇ w 2 f ( w k ^ , X ) ( w k − w ∗ ) ] E[\nabla_w f(w_k,X)] - E[\nabla_w f(w^*,X)] = E[\nabla^2_w f(\hat{w_k},X)(w_k - w^*)] E[wf(wk,X)]E[wf(w,X)]=E[w2f(wk^,X)(wkw)]中值定理 的结论。

由于 w k − w ∗ w_k - w^* wkw 不是随机变量,且由 Robbins-Monro 框架的收敛性条件, 0 < c ≤ ∇ w 2 f 0 < c \leq \nabla^2_w f 0<cw2f,可得:
∣ E [ ∇ w 2 f ( w k ^ , X ) ( w k − w ∗ ) ] ∣ = E [ ∇ w 2 f ( w k ^ , X ) ] ∣ ∣ w k − w ∗ ∣ ≥ c ∣ w k − w ∗ ∣ |E[\nabla^2_w f(\hat{w_k},X)(w_k - w^*)]| = E[\nabla^2_w f(\hat{w_k},X)]||w_k - w^*| \geq c |w_k - w^*| E[w2f(wk^,X)(wkw)]=E[w2f(wk^,X)]∣∣wkwcwkw

⇒ δ k ≤ ∣ ∇ w f ( w k , x k ) − E [ ∇ w f ( w k , X ) ] ∣ c ∣ w k − w ∗ ∣ \Rightarrow \delta_k \leq \frac{|\nabla_wf(w_k,x_k) - E[\nabla_w f(w_k,X)]|}{c |w_k - w^*|} δkcwkwwf(wk,xk)E[wf(wk,X)]

因此我们可以发现:

  • ∣ w k − w ∗ ∣ |w_k - w^*| wkw 比较大时, δ k \delta_k δk 的上界比较小,即此时 SGD 与 GD 的收敛速度比较接近
  • ∣ w k − w ∗ ∣ |w_k - w^*| wkw 比较小时, δ k \delta_k δk 的上界比较大,即此时 SGD 的收敛速度不太能保证,有较强的 随机性

时序差分方法

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

已知 π k → ( v π k ( 0 ) → v π k ( 1 ) → . . . → v π k ( ∞ ) = v π k ) → 求解 q π k ( s , a ) → π k + 1 = { 1 , a = a ∗ ( s ) 0 , a ≠ a ∗ ( s ) → . . . 已知 \pi_k \rightarrow (v_{\pi_k}^{(0)} \rightarrow v_{\pi_k}^{(1)} \rightarrow ... \rightarrow v_{\pi_k}^{(\infin)} = v_{\pi_k}) \rightarrow 求解 q_{\pi_k}(s,a) \rightarrow \pi_{k+1}= \begin{cases} 1, \quad a = a^*(s)\\ 0, \quad a \neq a^*(s) \end{cases} \rightarrow ... 已知πk(vπk(0)vπk(1)...vπk()=vπk)求解qπk(s,a)πk+1={1,a=a(s)0,a=a(s)...

其中 ( v π k ( 0 ) → v π k ( 1 ) → . . . → v π k ( ∞ ) = v π k ) (v_{\pi_k}^{(0)} \rightarrow v_{\pi_k}^{(1)} \rightarrow ... \rightarrow v_{\pi_k}^{(\infin)} = v_{\pi_k}) (vπk(0)vπk(1)...vπk()=vπk) 即是通过迭代求解一个求解一个贝尔曼公式:
v π k ( 1 ) = r π k + γ P π k v π k ( 0 ) v π k ( 2 ) = r π k + γ P π k v π k ( 1 ) … 贝尔曼公式 ⟵ v π k ( ∞ ) = r π k + γ P π k v π k ( ∞ ) \begin{aligned} 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{贝尔曼公式} \quad \longleftarrow \quad v_{\pi_k}^{(\infin)} &= r_{\pi_k} + \gamma P_{\pi_k} v_{\pi_k}^{(\infin)}\\ \end{aligned} vπk(1)vπk(2)贝尔曼公式vπk()=rπk+γPπkvπk(0)=rπk+γPπkvπk(1)=rπk+γPπkvπk()

但现在由于是 model-free 了,我们只能通过样本来求解 v π k v_{\pi_k} vπk。在 第一节 中, v π k v_{\pi_k} vπk 的原始定义是在 Policy 为 π k {\pi_k} πk, 从状态 s 出发时,所有可能的 trajectory 的 discounted return G t G_t Gt 的期望值: v π ( s ) = E [ G t ∣ S t = s ] = E [ R t + 1 + γ G t + 1 ∣ S t = s ] v_{\pi}(s) = E[G_t|S_t=s] = E[R_{t+1} + \gamma G_{t+1}|S_t = s] vπ(s)=E[GtSt=s]=E[Rt+1+γGt+1St=s]
又由于 E [ G t + 1 ∣ S t = s ] = v π ( S t + 1 ) E[G_{t+1}|S_t = s] = v_{\pi}(S_{t+1}) E[Gt+1St=s]=vπ(St+1)

因此:
v π ( s ) = E [ R t + 1 + γ v π ( S t + 1 ) ∣ S t = s ] v_{\pi}(s) = E[R_{t+1} + \gamma v_{\pi}(S_{t+1})|S_t = s] vπ(s)=E[Rt+1+γvπ(St+1)St=s]

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

g ( v π ( s t ) ) = v π ( s t ) − E [ R t + 1 + γ v π ( S t + 1 ) ∣ S t = s t ] 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π(st))=vπ(st)E[Rt+1+γvπ(St+1)St=st]
目标是求解: g ( v π ( s t ) ) = 0 g(v_{\pi}(s_t)) = 0 g(vπ(st))=0

上式就是我们前面讨论的 Mean estimation,每来一个样本 ( s t , r t + 1 , s t + 1 ) (s_t, r_{t+1}, s_{t+1}) (st,rt+1,st+1),其更新式为:
v t + 1 ( s t ) = v t ( s t ) − α t ( s t ) ( v t ( s t ) − [ r t + 1 + γ v t ( 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})]) vt+1(st)=vt(st)αt(st)(vt(st)[rt+1+γvt(st+1)])

其中 v t ˉ = r t + 1 + γ v t ( s t + 1 ) \bar{v_t} = r_{t+1} + \gamma v_t(s_{t+1}) vtˉ=rt+1+γvt(st+1) 称为 TD target δ t = v t ( s t ) − v t ˉ \delta_t = v_t(s_t) - \bar{v_t} δt=vt(st)vtˉ 则称为 TD error。注意这里: v t + 1 ( s ) = v t ( s ) , if  s ≠ s t v_{t+1}(s) = v_t(s), \text { if } s \neq s_t vt+1(s)=vt(s) if s=st
即,每学习一个样本, v t + 1 v_{t+1} vt+1 相比 v t v_t vt 只会更新当前样本涉及到的 state 的 state value(这是当然的)

如前面 Robbins-Monro 所讨论的,迭代的目标是减小 TD error,由于 g ( v π ( s t ) ) g(v_{\pi}(s_t)) g(vπ(st)) 是单调递增函数:

  • v t ( s t ) − v t ˉ < 0 v_t(s_t) - \bar{v_t} < 0 vt(st)vtˉ<0 时, v t + 1 ( s t ) v_{t+1}(s_t) vt+1(st) v t ( s t ) v_t(s_t) vt(st) 右边移一点
  • v t ( s t ) − v t ˉ > 0 v_t(s_t) - \bar{v_t} > 0 vt(st)vtˉ>0 时, v t + 1 ( s t ) v_{t+1}(s_t) vt+1(st) v t ( s t ) v_t(s_t) vt(st) 左边移一点

从数学上来说,因为当 v t = v π v_t = v_{\pi} vt=vπ 时:
E [ δ t ∣ S t = s t ] = E [ v π ( S t ) − ( R t + 1 + γ v π ( S t + 1 ) ) ∣ S t = s t ] = v π ( s t ) − E [ R t + 1 + γ v π ( S t + 1 ) ∣ S t = s t ] = 0 \begin{align} 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{align} E[δtSt=st]=E[vπ(St)(Rt+1+γvπ(St+1))St=st]=vπ(st)E[Rt+1+γvπ(St+1)St=st]=0

因此减小 TD error 即使得 v t v_t vt v π v_{\pi} vπ 靠近

与蒙特卡洛算法的区别

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

Sarsa 算法

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

已知 π k → 从 ( s , a ) 出发,做 n 次实验,有 n 个结果 g π k ( i ) ( s , a ) → 估计 q π k ( s , a ) = 1 n ∑ i g π k ( i ) ( s , a ) → π k + 1 = { 1 , a = a π k ( s ) 0 , a ≠ a π k ( s ) → . . . 已知 \pi_k \rightarrow 从 (s,a) 出发,做n次实验,有n个结果 g_{\pi_k}^{(i)}(s,a) \rightarrow 估计 q_{\pi_k}(s,a) = \frac{1}{n}\sum_i g_{\pi_k}^{(i)}(s,a) \rightarrow \pi_{k+1}= \begin{cases} 1, \quad a = a_{\pi_k}(s)\\ 0, \quad a \neq a_{\pi_k}(s) \end{cases} \rightarrow ... 已知πk(s,a)出发,做n次实验,有n个结果gπk(i)(s,a)估计qπk(s,a)=n1igπk(i)(s,a)πk+1={1,a=aπk(s)0,a=aπk(s)...

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

第一节 当中,我们推到过 action value 形式的贝尔曼公式,首先看常见的 state value 的贝尔曼公式:
v π ( s ) = ∑ a π ( a ∣ s ) [ ∑ r P ( r ∣ s , a ) r + γ ∑ s ′ P ( s ′ ∣ s , a ) v π ( s ′ ) ] , ∀ s \begin{aligned} v_{\pi}(s) = \sum_{a} \pi(a|s) [\sum_{r} P(r|s,a)r + \gamma \sum_{s'} P(s'|s,a) v_{\pi}(s')], \quad \forall s \end{aligned} vπ(s)=aπ(as)[rP(rs,a)r+γsP(ss,a)vπ(s)],s
由于
v π ( s ) = ∑ a π ( a ∣ s ) q π ( s , a ) v_{\pi}(s) = \sum_a \pi(a|s) q_{\pi}(s,a) vπ(s)=aπ(as)qπ(s,a)
因此上式等价于
q π ( s , a ) = ∑ r P ( r ∣ s , a ) r + γ ∑ s ′ P ( s ′ ∣ s , a ) v π ( s ′ ) = ∑ r P ( r ∣ s , a ) r + γ ∑ s ′ P ( s ′ ∣ s , a ) ∑ a ′ q π ( s ′ , a ′ ) π ( a ′ ∣ s ′ ) = ∑ r P ( r ∣ s , a ) r + γ ∑ s ′ ∑ a ′ q π ( s ′ , a ′ ) P ( s ′ ∣ s , a ) P ( a ′ ∣ s ′ ) = ∑ r P ( r ∣ s , a ) r + γ ∑ s ′ ∑ a ′ q π ( s ′ , a ′ ) P ( s ′ ∣ s , a ) P ( a ′ ∣ s ′ , s , a ) = ∑ r P ( r ∣ s , a ) r + γ ∑ s ′ ∑ a ′ q π ( s ′ , a ′ ) P ( s ′ , a ′ ∣ s , a ) = E [ R + γ q π ( S ′ , A ′ ) ∣ s , a ] \begin{aligned} q_{\pi}(s,a) &= \sum_{r} P(r|s,a)r + \gamma \sum_{s'} P(s'|s,a) v_{\pi}(s')\\ &= \sum_{r} P(r|s,a)r + \gamma \sum_{s'} P(s'|s,a) \sum_{a'} q_{\pi}(s',a') \pi(a'|s')\\ &= \sum_{r} P(r|s,a)r + \gamma \sum_{s'}\sum_{a'} q_{\pi}(s',a') P(s'|s,a) P(a'|s')\\ &= \sum_{r} P(r|s,a)r + \gamma \sum_{s'}\sum_{a'} q_{\pi}(s',a') P(s'|s,a) P(a'|s',s,a)\\ &= \sum_{r} P(r|s,a)r + \gamma \sum_{s'}\sum_{a'} q_{\pi}(s',a') P(s',a'|s,a)\\ &= E[R + \gamma q_{\pi}(S',A')|s,a] \end{aligned} qπ(s,a)=rP(rs,a)r+γsP(ss,a)vπ(s)=rP(rs,a)r+γsP(ss,a)aqπ(s,a)π(as)=rP(rs,a)r+γsaqπ(s,a)P(ss,a)P(as)=rP(rs,a)r+γsaqπ(s,a)P(ss,a)P(as,s,a)=rP(rs,a)r+γsaqπ(s,a)P(s,as,a)=E[R+γqπ(S,A)s,a]

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

g ( q π ( s t , a t ) ) = q π ( s t , a t ) − E [ R t + 1 + γ q π ( S t + 1 , A t + 1 ) ∣ S t = s t , A t = a t ] 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π(st,at))=qπ(st,at)E[Rt+1+γqπ(St+1,At+1)St=st,At=at]
目标是求解: g ( q π ( s t , a t ) ) = 0 g(q_{\pi}(s_t,a_t)) = 0 g(qπ(st,at))=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 ) − α t ( s t , a t ) [ q t ( s t , a t ) − ( r t + 1 + γ q t ( s t + 1 , a t + 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}))] qt+1(st,at)=qt(st,at)αt(st,at)[qt(st,at)(rt+1+γqt(st+1,at+1))]
同样有: q t + 1 ( s , a ) = q t ( s , a ) , ∀ ( s , a ) ≠ ( s t , a t ) q_{t+1}(s,a) = q_t(s,a), \qquad \forall (s,a) \neq (s_t,a_t) qt+1(s,a)=qt(s,a),(s,a)=(st,at)

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),就会立即更新 q t + 1 ( s t , a t ) q_{t+1}(s_t,a_t) qt+1(st,at) 然后立马就更新 Policy π t + 1 \pi_{t+1} πt+1,并且由这个 Policy 来采下一个样本,这里采用 ϵ \epsilon ϵ-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 非常接近:

q t + 1 ( s t , a t ) = q t ( s t , a t ) − α t ( s t , a t ) [ q t ( s t , a t ) − ( r t + 1 + γ E [ q t ( s t + 1 , A ) ] ) ] q t + 1 ( s , a ) = q t ( s , a ) , ∀ ( s , a ) ≠ ( s t , a t ) \begin{align} 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), \qquad \forall (s,a) \neq (s_t,a_t) \end{align} qt+1(st,at)qt+1(s,a)=qt(st,at)αt(st,at)[qt(st,at)(rt+1+γE[qt(st+1,A)])]=qt(s,a),(s,a)=(st,at)

其中 E [ q t ( s t + 1 , A ) ] = ∑ a π t ( a ∣ s t + 1 ) q t ( s t + 1 , a ) = v t ( s t + 1 ) 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}) E[qt(st+1,A)]=aπt(ast+1)qt(st+1,a)=vt(st+1)

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

q π ( s , a ) = E [ R t + 1 + γ E [ q π ( S t + 1 , A t + 1 ) ∣ S t + 1 ] ∣ S t = s , A t = a ] = E [ R t + 1 + γ v π ( S t + 1 ) ∣ S t = s , A t = a ] \begin{align} 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{align} qπ(s,a)=E[Rt+1+γE[qπ(St+1,At+1)St+1]St=s,At=a]=E[Rt+1+γvπ(St+1)St=s,At=a]

上式等价于贝尔曼公式的原因是:
v π ( s ) = E [ R t + 1 + γ v π ( S t + 1 ) ∣ S t = s ] = ∑ a π ( a ∣ s ) E [ R t + 1 + γ v π ( S t + 1 ) ∣ S t = s , A t = a ] = ∑ a π ( a ∣ s ) q π ( s , a ) \begin{align} 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{align} vπ(s)=E[Rt+1+γvπ(St+1)St=s]=aπ(as)E[Rt+1+γvπ(St+1)St=s,At=a]=aπ(as)qπ(s,a)

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 π ( s , a ) = E [ G t ∣ S t = s , A t = a ] q_{\pi}(s,a) = E[G_t | S_t = s, A_t = a] qπ(s,a)=E[GtSt=s,At=a]
G t G_t Gt 可以分解成 G t = R t + 1 + γ R t + 2 + γ 2 R t + 3 + . . . G_t = R_{t+1} + \gamma R_{t+2} + \gamma^2 R_{t+3} + ... Gt=Rt+1+γRt+2+γ2Rt+3+...
或者更细的拆分:
Sarsa ← G t ( 1 ) = R t + 1 + γ q π ( S t + 1 , A t + 1 ) G t ( 2 ) = R t + 1 + γ R t + 2 + γ 2 q π ( S t + 2 , A t + 2 ) … n-step Sarsa ← G t ( n ) = R t + 1 + γ R t + 2 + . . . + γ n q π ( S t + n , A t + n ) … 蒙特卡洛算法 ← G t ( ∞ ) = R t + 1 + γ R t + 2 + γ 2 R t + 3 + γ 3 R t + 4 + . . . \begin{aligned} \text{Sarsa} \leftarrow \quad 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 \quad G_t^{(n)} &= R_{t+1} + \gamma R_{t+2} + ... + \gamma^n q_{\pi}(S_{t+n},A_{t+n})\\ \dots\\ \text{蒙特卡洛算法} \leftarrow \quad G_t^{(\infin)} &= R_{t+1} + \gamma R_{t+2} + \gamma^2 R_{t+3} + \gamma^3 R_{t+4} + ... \end{aligned} SarsaGt(1)Gt(2)n-step SarsaGt(n)蒙特卡洛算法Gt()=Rt+1+γqπ(St+1,At+1)=Rt+1+γRt+2+γ2qπ(St+2,At+2)=Rt+1+γRt+2+...+γnqπ(St+n,At+n)=Rt+1+γRt+2+γ2Rt+3+γ3Rt+4+...

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 的迭代式:

q t + 1 ( s t , a t ) = q t ( s t , a t ) − α t ( s t , a t ) [ q t ( s t , a t ) − ( r t + 1 + γ max ⁡ a q t ( s t + 1 , a ) ) ] q t + 1 ( s , a ) = q t ( s , a ) , ∀ ( s , a ) ≠ ( s t , a t ) \begin{align} 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 \max_{a} q_t(s_{t+1},a))]\\ q_{t+1}(s,a) &= q_t(s,a), \qquad \forall (s,a) \neq (s_t,a_t) \end{align} qt+1(st,at)qt+1(s,a)=qt(st,at)αt(st,at)[qt(st,at)(rt+1+γamaxqt(st+1,a))]=qt(s,a),(s,a)=(st,at)

Q-learning 的本质是 贝尔曼最优公式,这是因为:
q ( s , a ) = E [ R t + 1 + γ max ⁡ a q ( S t + 1 , a ) ∣ S t = s , A t = a ] = ∑ r P ( r ∣ s , a ) r + γ ∑ s ′ P ( s ′ ∣ s , a ) max ⁡ a q ( s ′ , a ) \begin{aligned} q(s,a) &= E[R_{t+1} + \gamma \max_{a} q(S_{t+1},a) |S_t = s, A_t=a ]\\ &= \sum_r P(r|s,a)r + \gamma \sum_{s'} P(s'|s,a) \max_{a} q(s',a)\\ \end{aligned} q(s,a)=E[Rt+1+γamaxq(St+1,a)St=s,At=a]=rP(rs,a)r+γsP(ss,a)amaxq(s,a)

由于 贝尔曼最优公式 v ∗ ( s ) = max ⁡ a q ( s , a ) v^*(s) = \max_a q(s,a) v(s)=maxaq(s,a),因此上式等价于
v ∗ ( s ) = max ⁡ a [ ∑ r P ( r ∣ s , a ) r + γ ∑ s ′ P ( s ′ ∣ s , a ) v ∗ ( s ′ ) ] = max ⁡ π ∑ a π ( a ∣ s ) [ ∑ r P ( r ∣ s , a ) r + γ ∑ s ′ P ( s ′ ∣ s , a ) v ∗ ( s ′ ) ] \begin{aligned} v^*(s) &= \max_a [\sum_r P(r|s,a)r + \gamma \sum_{s'} P(s'|s,a) v^*(s')]\\ &= \max_{\pi} \sum_a \pi(a|s) [\sum_r P(r|s,a)r + \gamma \sum_{s'} P(s'|s,a) v^*(s')] \end{aligned} v(s)=amax[rP(rs,a)r+γsP(ss,a)v(s)]=πmaxaπ(as)[rP(rs,a)r+γsP(ss,a)v(s)]

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

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(我们前面讨论的绝大部分算法都是这种,这也是这些算法要用 ϵ \epsilon ϵ-greedy 而不是直接 greedy 算法更新策略的原因)

Q-learning 是目前为止的第一个 off-policy 算法,核心原因就是因为它求解的是贝尔曼 最优 公式 ,而其他算法求解的只是贝尔曼公式,对比 Q-learning 和 Sarsa 的迭代式
Q-learning :  q t + 1 ( s t , a t ) = q t ( s t , a t ) − α t ( s t , a t ) [ q t ( s t , a t ) − ( r t + 1 + γ max ⁡ a q t ( s t + 1 , a ) ) ] Sarsa :  q t + 1 ( s t , a t ) = q t ( s t , a t ) − α t ( s t , a t ) [ q t ( s t , a t ) − ( r t + 1 + γ q t ( s t + 1 , a t + 1 ) ) ] \begin{aligned} \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 \max_{a} 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{aligned} Q-learning : qt+1(st,at)Sarsa : qt+1(st,at)=qt(st,at)αt(st,at)[qt(st,at)(rt+1+γamaxqt(st+1,a))]=qt(st,at)αt(st,at)[qt(st,at)(rt+1+γqt(st+1,at+1))]
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 s_t, a_t st,at 是当前步给定的,而 r t + 1 , s t + 1 r_{t+1}, s_{t+1} rt+1,st+1 是仅依赖于 model: P ( R ∣ s , a ) P(R|s,a) P(Rs,a) P ( S ′ ∣ s , a ) P(S'|s,a) P(Ss,a),与 Policy 无关。重点在于 a t + 1 a_{t+1} at+1 ,一方面它依赖 behavior policy 生成,另一方面,它又用来更新了 target policy 的 action value,这就要求 a t + 1 a_{t+1} at+1 实际也是 target policy 在给定 s t , a t s_t, a_t st,at 的选择(否则定义就不对了)

反观 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 s_t, a_t st,at 时是不依赖 Policy 的,因此这里 target policy 可以和 behavior policy 解耦。因此它的 behavior policy 可以取得非常 exploration,这样可以使得取到的样本对每一个 state 都充分访问,也更有利于 target policy 的效果,以下是一个例子:

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

下面再看一个例子,这个例子里,直接将 ϵ \epsilon ϵ 取为了1 (因此各个 action 概率均等):

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


总结

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

q t + 1 ( s t , a t ) = q t ( s t , a t ) − α ( s t , a t ) [ q t ( s t , a t ) − q ˉ t ] 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] qt+1(st,at)=qt(st,at)α(st,at)[qt(st,at)qˉt]

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


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

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/web/47236.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

电容认识和特点总结

图片 常见的电容名字及特点 名字特点容量和耐压独石电容MLCCMulti layer Ceramic Capacitors (多层陶瓷电容) 常见的贴片电容&#xff0c;容量大于瓷片电容0.5pF~100uF,耐压<100V瓷片/陶瓷电容耐压远高于独石电容,容量小<0.1uf&#xff0c;用于晶振旁路电容滤波铝电解电…

PY32F002B单片机 ISP 串口下载注意事项

一、PY32F002B ISP 串口下载的连接方式 仿真上的 VCC 和 GND 连接到 MCU 的 VCC 和 VSS&#xff0c; 仿真的 TX 接 MCU 的 RX&#xff0c;RX 接 MCU 的 TX。 二、因为 PY32F002B 没有 BOOT&#xff0c;需要用 ISP 串口下载的话需要下载串口引导程序。 下载这个目录下的 IAP…

Python酷库之旅-第三方库Pandas(036)

目录 一、用法精讲 111、pandas.Series.item方法 111-1、语法 111-2、参数 111-3、功能 111-4、返回值 111-5、说明 111-6、用法 111-6-1、数据准备 111-6-2、代码示例 111-6-3、结果输出 112、pandas.Series.xs方法 112-1、语法 112-2、参数 112-3、功能 112-…

几种常用排序算法

1 基本概念 排序是处理数据的一种最常见的操作&#xff0c;所谓排序就是将数据按某字段规律排列&#xff0c;所谓的字段就是数据节点的其中一个属性。比如一个班级的学生&#xff0c;其字段就有学号、姓名、班级、分数等等&#xff0c;我们既可以针对学号排序&#xff0c;也可…

OpenGL-ES 学习(7) ---- VBO EBO 和 VAO

目录 VBO(Vertex Buffer Object)EBO(Element Buffer Object)VAO(Vertex Array Object) VBO(Vertex Buffer Object) EBO(Element Buffer Object) VBO(Vertex Buffer Object) 实际是指顶点缓冲器对象 在 opengl-es 2.0 的编程中&#xff0c;用于绘制图元的顶点数据是从 CPU 传…

暑假第一周学习内容-ZARA仿写

仿写ZARA总结 文章目录 仿写ZARA总结前言无限轮播图分栏控制器与UIScrollViewUIScorllView的协议部分UISegmentedControl的协议部分 自定义cell 前言 本文主要是用来总结仿写ZARA中遇到的一些问题&#xff0c;以及ZARA中学习到的一些新知识。 无限轮播图 这里我们先给出无限…

使用Windows Linux 子系统安装 Tensorflow,并使用GPU环境

在Microsoft Store商店安装Ubuntu 20.04 使用 nvidia-smi 命令查看GPU信息&#xff0c;查看支持的CUDA版本&#xff0c;这里最高支持11.7 安装cuda工具集 进入官网&#xff1a;CUDA Toolkit Archive | NVIDIA Developer&#xff0c;现在对应版本&#xff0c;点击 配置平台&…

LeNet实验 四分类 与 四分类变为多个二分类

目录 1. 划分二分类 2. 训练独立的二分类模型 3. 二分类预测结果代码 4. 二分类预测结果 5 改进训练模型 6 优化后 预测结果代码 7 优化后预测结果 8 训练四分类模型 9 预测结果代码 10 四分类结果识别 1. 划分二分类 可以根据不同的类别进行多个划分&#xff0c;以…

科研绘图系列:R语言分割小提琴图(Split-violin)

介绍 分割小提琴图(Split-violin plot)是一种数据可视化工具,它结合了小提琴图(violin plot)和箱线图(box plot)的特点。小提琴图是一种展示数据分布的图形,它通过在箱线图的两侧添加曲线来表示数据的密度分布,曲线的宽度表示数据点的密度。而分割小提琴图则是将小提…

绿色算力|暴雨服务器用芯片筑起“十四五”转型新篇章

面对全球气候变化、技术革新以及能源转型的新形势&#xff0c;发展低碳、高效的绿色算力不仅是顺应时代的要求&#xff0c;更是我国建设数字基础设施和展现节能减碳大国担当的重要命题&#xff0c;在此背景下也要求在提升算力规模和性能的同时&#xff0c;积极探索推动算力基础…

【iOS】APP仿写——网易云音乐

网易云音乐 启动页发现定时器控制轮播图UIButtonConfiguration 发现换头像 我的总结 启动页 这里我的启动页是使用Xcode自带的启动功能&#xff0c;将图片放置在LaunchScreen中即可。这里也可以通过定时器控制&#xff0c;来实现启动的效果 效果图&#xff1a; 这里放一篇大…

31_MobileViT网络讲解

VIT:https://blog.csdn.net/qq_51605551/article/details/140445491?spm1001.2014.3001.5501 1.1 简介 MobileVIT是“Mobile Vision Transformer”的简称&#xff0c;是一种专门为移动设备设计的高效视觉模型。它结合了Transformer架构的优点与移动优先的设计原则&#xff0…

在eclipse中导入本地的jar包配置Junit环境步骤(包含Junit中的方法一直标红的解决方法)

搭建JUnit环境 一、配置环境 跟上一篇的那种方法不一样&#xff0c;直接Add to Build Path 是先将jar包复制到项目的lib目录下&#xff0c;然后直接添加 选定项目>>>右键>>>Bulid Path>>>Add Libraries>>>Configure Build Path(配置构建路…

python—爬虫爬取电影页面实例

下面是一个简单的爬虫实例&#xff0c;使用Python的requests库来发送HTTP请求&#xff0c;并使用lxml库来解析HTML页面内容。这个爬虫的目标是抓取一个电影网站&#xff0c;并提取每部电影的主义部分。 首先&#xff0c;确保你已经安装了requests和lxml库。如果没有安装&#x…

Fast Planner规划算法(一)—— Fast Planner前端

本系列文章用于回顾学习记录Fast-Planner规划算法的相关内容&#xff0c;【本系列博客写于2023年9月&#xff0c;共包含四篇文章&#xff0c;现在进行补发第一篇&#xff0c;其余几篇文章将在近期补发】 一、Fast Planner前端 Fast Planner的轨迹规划部分一共分为三个模块&…

4.基础知识-数据库技术基础

基础知识 一、数据库基本概念1、数据库系统基础知识2、三级模式-两级映像3、数据库设计4、数据模型&#xff1a;4.1 E-R模型★4.2 关系模型★ 5、关系代数 二、规范化和并发控制1、函数依赖2、键与约束3、范式★3.1 第一范式1NF实例3.2 第二范式2NF3.3 第三范式3NF3.4 BC范式BC…

rockchip的yolov5 rknn python推理分析

rockchip的yolov5 rknn推理分析 对于rockchip给出的这个yolov5后处理代码的分析&#xff0c;本人能力十分有限&#xff0c;可能有的地方描述的很不好&#xff0c;欢迎大家和我一起讨论&#xff0c;指出我的错误&#xff01;&#xff01;&#xff01; RKNN模型输出 将官方的Y…

直方图的最大长方形面积

前提知识&#xff1a;单调栈基础题-CSDN博客 子数组的最大值-CSDN博客 题目描述&#xff1a; 给定一个非负数&#xff08;0和正数&#xff09;&#xff0c;代表直方图&#xff0c;返回直方图的最大长方形面积&#xff0c;比如&#xff0c;arr {3, 2, 4, 2, 5}&#xff0c…

景区导航导览系统:基于AR技术+VR技术的功能效益全面解析

在数字化时代背景下&#xff0c;游客对旅游体验的期望不断提升。游客们更倾向于使用手机作为旅行的贴身助手&#xff0c;不仅因为它能提供实时、精准的导航服务&#xff0c;更在于其融合AR&#xff08;增强现实&#xff09;、VR&#xff08;虚拟现实&#xff09;等前沿技术&…

十三、网络编程正则表达式设计模式(模块23)

网络编程&正则表达式&设计模式 模块23_网络编程&正则表达式&设计模式第一章.网络编程1.软件结构2.服务器概念3.通信三要素4.UDP协议编程4.1.客户端(发送端)4.2.服务端(接收端) 5.TCP协议编程4.1.编写客户端4.2.编写服务端 6.文件上传6.1.文件上传客户端以及服务…