跳到主要内容

时序差分算法

1. 时序差分方法​

在动态规划中,我们定义了两个完全已知的场景:悬崖漫步和冰湖环境,来实验我们的动态规划方法。但是,实际上我们在做simulation或者sim2real的时候,环境是未知的,这导致我们无法直接得出马尔可夫决策过程的状态转移概率。此时,智能体只能和环境进行交互,通过采样到的数据来学习,这类学习方法统称为无模型的强化学习(model-free reinforcement learning)。 因此,我们需要一种不依赖于环境模型的方法来评估和改进策略,这就是时序差分(Temporal Difference, TD)方法。

时序差分是一种用来估计一个策略的价值函数的方法,它结合了蒙特卡洛和动态规划算法的思想。时序差分方法和蒙特卡洛的相似之处在于可以从样本数据中学习,不需要事先知道环境;和动态规划的相似之处在于根据贝尔曼方程的思想,利用后续状态的价值估计来更新当前状态的价值估计。回顾一下蒙特卡洛方法对价值函数的增量更新方式:

V(St)←V(St)+α[Gt−V(St)]V(S_t) \leftarrow V(S_t) + \alpha[G_t - V(S_t)]

这里我们将蒙特卡洛增量更新中的 1N(St)\frac{1}{N(S_t)} 替换成了 α\alpha,表示对价值估计更新的步长。可以将 α\alpha 取为一个常数,此时更新方式不再像蒙特卡洛方法那样严格地取期望。蒙特卡洛方法必须要等整个序列结束之后才能计算得到这一次的回报 GtG_t,而时序差分方法只需要当前步结束即可进行计算。具体来说,时序差分算法用当前获得的奖励加上下一个状态的价值估计来作为在当前状态会获得的回报,即:

V(St)←V(St)+α[Rt+1+γV(St+1)−V(St)]V(S_t) \leftarrow V(S_t) + \alpha[R_{t+1} + \gamma V(S_{t+1}) - V(S_t)]

其中 δt=Rt+1+γV(St+1)−V(St)\delta_t = R_{t+1} + \gamma V(S_{t+1}) - V(S_t) 通常被称为时序差分(temporal difference,TD)误差(error),时序差分算法将其与步长的乘积作为状态价值的更新量。可以用 Rt+1+γV(St+1)R_{t+1} + \gamma V(S_{t+1}) 来代替 GtG_t 的原因是:

Vπ(s)=Eπ[Gt∣St=s]=Eπ[Rt+1+γRt+2+γ2Rt+3+⋯∣St=s]=Eπ[Rt+1+γ(Rt+2+γRt+3+⋯ )∣St=s]=Eπ[Rt+1+γGt+1∣St=s]≈Eπ[Rt+1+γVπ(St+1)∣St=s]\begin{aligned} V_\pi(s) &= \mathbb{E}_\pi[G_t | S_t = s] \\ &= \mathbb{E}_\pi[R_{t+1} + \gamma R_{t+2} + \gamma^2 R_{t+3} + \cdots | S_t = s] \\ &= \mathbb{E}_\pi[R_{t+1} + \gamma (R_{t+2} + \gamma R_{t+3} + \cdots) | S_t = s] \\ &= \mathbb{E}_\pi[R_{t+1} + \gamma G_{t+1} | S_t = s] \\ &\approx \mathbb{E}_\pi[R_{t+1} + \gamma V_\pi(S_{t+1}) | S_t = s] \end{aligned}

因此蒙特卡洛方法将上式第一行作为更新的目标,而时序差分算法将上式最后一行作为更新的目标。于是,在用策略和环境交互时,每采样一步,我们就可以用时序差分算法来更新状态价值估计。时序差分算法用到了 V(St+1)V(S_{t+1}) 的估计值,可以证明它最终收敛到策略的价值函数,我们在此不对此进行展开说明。

2. Sarsa 算法​

既然我们可以用时序差分方法来估计价值函数,那一个很自然的问题是,我们能否用类似策略迭代的方法来进行强化学习。策略评估已经可以通过时序差分算法实现,那么在不知道奖励函数和状态转移函数的情况下该怎么进行策略提升呢?答案是我们可以直接用时序差分算法来估计动作价值函数 Q(s,a)Q(s,a):

Q(St,At)←Q(St,At)+α[Rt+1+γQ(St+1,At+1)−Q(St,At)]Q(S_t, A_t) \leftarrow Q(S_t, A_t) + \alpha[R_{t+1} + \gamma Q(S_{t+1}, A_{t+1}) - Q(S_t, A_t)]

然后我们用贪婪算法来选取在某个状态下动作价值最大的那个动作,即 π(s)=arg⁡max⁡aQ(s,a)\pi(s) = \arg\max_a Q(s,a)。这样似乎已经形成了一个完整的强化学习算法:用贪婪算法根据动作价值选取动作来和环境交互,再根据得到的数据用时序差分算法更新动作价值估计。

然而这个简单的算法存在两个需要进一步考虑的问题。第一,如果要用时序差分算法来准确地估计策略的状态价值函数,我们需要用极大量的样本来进行更新。但实际上可以只用部分样本评估策略,然后立即更新策略;价值迭代也采用了这种策略评估与提升交错进行的广义策略迭代(generalized policy iteration)思想。第二,如果在策略提升中一直根据贪婪算法得到一个确定性策略,可能会导致某些状态动作对 (s,a)(s,a) 永远没有在序列中出现,以至于无法对其动作价值进行估计,进而无法保证策略提升后的策略比之前的好。简单常用的解决方案是不再一味使用贪婪算法,而是采用一个 ϵ\epsilon-贪婪策略:以 1−ϵ1-\epsilon 的概率采用动作价值最大的那个动作,另外有 ϵ\epsilon 的概率从动作空间中随机采取一个动作,其公式表示为:

π(a∣s)={1−ϵ+ϵ∣A(s)∣if a=arg⁡max⁡a′Q(s,a′)ϵ∣A(s)∣otherwise\pi(a|s) = \begin{cases} 1 - \epsilon + \frac{ \epsilon}{|A(s)|} & \text{if } a = \arg\max_{a'} Q(s, a') \\ \frac{\epsilon}{|A(s)|} & \text{otherwise} \end{cases}

现在,我们就可以得到一个实际的基于时序差分方法的强化学习算法。这个算法被称为 Sarsa,因为它的动作价值更新用到了当前状态 StS_t、当前动作 AtA_t、获得的奖励 Rt+1R_{t+1}、下一个状态 St+1S_{t+1} 和下一个动作 At+1A_{t+1},将这些符号拼接后就得到了算法名称。Sarsa 的具体算法如下:

算法:Sarsa(在线策略时序差分控制)

  • 初始化 Q(s,a)Q(s,a),对于所有 s∈S,a∈A(s)s \in \mathcal{S}, a \in \mathcal{A}(s)
  • 设置参数 α\alpha(步长),ϵ\epsilon(探索率),γ\gamma(折扣因子)
  • for 每个回合(episode) do:
    • 得到初始状态 SS
    • 用 ϵ\epsilon-greedy 策略根据 QQ 选择当前状态 SS 下的动作 AA
    • for 每个时间步 do:
      • 执行动作 AA,得到环境反馈的奖励 RR 和下一个状态 S′S'
      • 用 ϵ\epsilon-greedy 策略根据 QQ 选择下一个状态 S′S' 下的动作 A′A'
      • 更新动作价值函数:Q(S,A)←Q(S,A)+α[R+γQ(S′,A′)−Q(S,A)]Q(S,A) \leftarrow Q(S,A) + \alpha[R + \gamma Q(S',A') - Q(S,A)]
      • S←S′S \leftarrow S', A←A′A \leftarrow A'
    • until SS 是终止状态
  • end for

3. 多步 Sarsa 算法​

蒙特卡洛方法利用当前状态之后每一步的奖励而不使用任何价值估计,时序差分算法只利用一步奖励和下一个状态的价值估计。那它们之间的区别是什么呢?总的来说,蒙特卡洛方法是无偏(unbiased)的,但是具有比较大的方差,因为每一步的状态转移都有不确定性,而每一步状态采取的动作所得到的不一样的奖励最终都会加起来,这会极大影响最终的价值估计;时序差分算法具有非常小的方差,因为只关注了一步状态转移,用到了一步的奖励,但是它是有偏的,因为用到了下一个状态的价值估计而不是其真实的价值。那有没有什么方法可以结合二者的优势呢?答案是多步时序差分!多步时序差分的意思是使用 nn 步的奖励,然后使用之后状态的价值估计。用公式表示,将 GtG_t 替换为 nn 步回报:

Gt(n)=Rt+1+γRt+2+γ2Rt+3+⋯+γn−1Rt+n+γnV(St+n)G_t^{(n)} = R_{t+1} + \gamma R_{t+2} + \gamma^2 R_{t+3} + \cdots + \gamma^{n-1} R_{t+n} + \gamma^n V(S_{t+n})

于是,相应存在一种多步 Sarsa 算法,它把前述 Sarsa 动作价值函数的单步更新公式:

Q(St,At)←Q(St,At)+α[Rt+1+γQ(St+1,At+1)−Q(St,At)]Q(S_t, A_t) \leftarrow Q(S_t, A_t) + \alpha[R_{t+1} + \gamma Q(S_{t+1}, A_{t+1}) - Q(S_t, A_t)]

替换为基于 nn 步回报的更新形式:

Q(St,At)←Q(St,At)+α[Gt(n)−Q(St,At)]Q(S_t, A_t) \leftarrow Q(S_t, A_t) + \alpha[G_t^{(n)} - Q(S_t, A_t)]

其中 nn 步动作价值回报定义为:

Gt(n)=Rt+1+γRt+2+⋯+γn−1Rt+n+γnQ(St+n,At+n)G_t^{(n)} = R_{t+1} + \gamma R_{t+2} + \cdots + \gamma^{n-1} R_{t+n} + \gamma^n Q(S_{t+n}, A_{t+n})

这种多步学习方法在偏差和方差之间提供了一个平衡点:当 n=1n=1 时就是标准的时序差分方法(低方差但有偏),当 nn 趋近于无穷大时就是蒙特卡洛方法(无偏但高方差)。通过选择合适的 nn 值,我们可以在两种极端情况之间找到一个较好的折衷。

4. Q-learning 算法​

除了 Sarsa,还有一种非常著名的基于时序差分算法的强化学习算法——Q-learning。Q-learning 和 Sarsa 的最大区别在于 Q-learning 的时序差分更新方式为:

Q(St,At)←Q(St,At)+α[Rt+1+γmax⁡aQ(St+1,a)−Q(St,At)]Q(S_t, A_t) \leftarrow Q(S_t, A_t) + \alpha[R_{t+1} + \gamma \max_a Q(S_{t+1}, a) - Q(S_t, A_t)]

Q-learning 算法的具体流程如下:

算法:Q-learning(离线策略时序差分控制)

  • 初始化 Q(s,a)Q(s,a),对于所有 s∈S,a∈A(s)s \in \mathcal{S}, a \in \mathcal{A}(s)
  • 设置参数 α\alpha(步长),ϵ\epsilon(探索率),γ\gamma(折扣因子)
  • for 每个回合(episode) do:
    • 得到初始状态 SS
    • for 每个时间步 do:
      • 用 ϵ\epsilon-greedy 策略根据 QQ 选择当前状态 SS 下的动作 AA
      • 执行动作 AA,得到环境反馈的奖励 RR 和下一个状态 S′S'
      • 更新动作价值函数:Q(S,A)←Q(S,A)+α[R+γmax⁡a′Q(S′,a′)−Q(S,A)]Q(S,A) \leftarrow Q(S,A) + \alpha[R + \gamma \max_{a'} Q(S', a') - Q(S,A)]
      • S←S′S \leftarrow S'
      • until SS 是终止状态
    • end for end for

我们可以用价值迭代的思想来理解 Q-learning,即 Q-learning 是直接在估计最优动作价值函数 Q∗Q^*,因为动作价值函数的贝尔曼最优方程是:

Q∗(s,a)=E[Rt+1+γmax⁡a′Q∗(St+1,a′)∣St=s,At=a]Q^*(s,a) = \mathbb{E}[R_{t+1} + \gamma \max_{a'} Q^*(S_{t+1}, a') | S_t = s, A_t = a]

而 Sarsa 估计当前 ϵ\epsilon-贪婪策略的动作价值函数。需要强调的是,Q-learning 的更新并非必须使用当前贪心策略采样得到的数据,因为给定任意 (St,At,Rt+1,St+1)(S_t, A_t, R_{t+1}, S_{t+1}) 都可以直接根据更新公式来更新 Q(St,At)Q(S_t, A_t),为了探索,我们通常使用一个 ϵ\epsilon-贪婪策略来与环境交互。Sarsa 必须使用当前 ϵ\epsilon-贪婪策略采样得到的数据,因为它的更新中用到的 At+1A_{t+1} 是当前策略在 St+1S_{t+1} 下的动作。我们称 Sarsa 是在线策略(on-policy)算法,称 Q-learning 是离线策略(off-policy)算法,这两个概念在强化学习中非常重要。

我们称采样数据的策略为行为策略(behavior policy),称用这些数据来更新的策略为目标策略(target policy)。在线策略(on-policy)算法表示行为策略和目标策略是同一个策略;而离线策略(off-policy)算法表示行为策略和目标策略不是同一个策略。Sarsa 是典型的在线策略算法,而 Q-learning 是典型的离线策略算法。判断二者类别的一个重要手段是看计算时序差分目标所用的下一动作是否来自当前行为策略。具体而言:

Sarsa(在线策略)- "言行一致的学习者"

  • 更新公式:Q(St,At)←Q(St,At)+α[Rt+1+γQ(St+1,At+1)−Q(St,At)]Q(S_t, A_t) \leftarrow Q(S_t, A_t) + \alpha[R_{t+1} + \gamma Q(S_{t+1}, A_{t+1}) - Q(S_t, A_t)]
  • 必须使用来自当前策略采样得到的五元组 (St,At,Rt+1,St+1,At+1)(S_t, A_t, R_{t+1}, S_{t+1}, A_{t+1})
  • At+1A_{t+1} 必须是根据当前策略在状态 St+1S_{t+1} 下选择的动作
  • 就像一个"言行一致"的人,用自己实际行动的结果来修正自己的价值观

Q-learning(离线策略)- "博采众长的观察者"

  • 更新公式:Q(St,At)←Q(St,At)+α[Rt+1+γmax⁡aQ(St+1,a)−Q(St,At)]Q(S_t, A_t) \leftarrow Q(S_t, A_t) + \alpha[R_{t+1} + \gamma \max_a Q(S_{t+1}, a) - Q(S_t, A_t)]
  • 只需要四元组 (St,At,Rt+1,St+1)(S_t, A_t, R_{t+1}, S_{t+1}) 来更新当前状态动作对的价值
  • 数据中的 AtA_t 和 St+1S_{t+1} 可以由任意行为策略产生,不一定是当前目标策略
  • 就像一个"博采众长"的观察者,可以从他人的经验中学习,不受限于自身的行动方式

这种区别使得 Q-learning 更加灵活,能够利用历史数据或其他策略收集的数据进行学习,而 Sarsa 则更加注重当前策略的实际表现,在学习过程中更加谨慎。

Image

5. CliffWalking 中的 Sarsa 与 Q-learning​

下面的示例可直接运行,依赖 gymnasium 和 numpy。两种算法使用相同的环境、超参数与随机种子,并遵循 Gymnasium 的新式 reset/step 返回约定。终止或截断后不再引导下一状态价值,避免把终止状态的估计错误地加入 TD 目标。

import gymnasium as gym
import numpy as np


def epsilon_greedy(q, state, epsilon, rng):
if rng.random() < epsilon:
return int(rng.integers(q.shape[1]))
best_actions = np.flatnonzero(q[state] == q[state].max())
return int(rng.choice(best_actions))


def train(algorithm, episodes=500, alpha=0.5, gamma=1.0,
epsilon=0.1, seed=0):
env = gym.make("CliffWalking-v1")
rng = np.random.default_rng(seed)
q = np.zeros((env.observation_space.n, env.action_space.n))
episode_returns = []

for episode in range(episodes):
state, _ = env.reset(seed=seed + episode)
action = epsilon_greedy(q, state, epsilon, rng)
total_reward = 0.0

while True:
next_state, reward, terminated, truncated, _ = env.step(action)
done = terminated or truncated
total_reward += reward

if algorithm == "sarsa":
next_action = (
None if done
else epsilon_greedy(q, next_state, epsilon, rng)
)
bootstrap = 0.0 if done else q[next_state, next_action]
elif algorithm == "q_learning":
next_action = None
bootstrap = 0.0 if done else q[next_state].max()
else:
raise ValueError("algorithm 必须是 'sarsa' 或 'q_learning'")

td_target = reward + gamma * bootstrap
q[state, action] += alpha * (td_target - q[state, action])

if done:
break
state = next_state
action = (
next_action
if algorithm == "sarsa"
else epsilon_greedy(q, state, epsilon, rng)
)

episode_returns.append(total_reward)

env.close()
return q, np.asarray(episode_returns)


def greedy_policy(q):
arrows = np.array(["↑", "→", "↓", "←"])
policy = arrows[np.argmax(q, axis=1)].reshape(4, 12)
policy[3, 1:11] = "C"
policy[3, 11] = "G"
return policy


if __name__ == "__main__":
sarsa_q, sarsa_returns = train("sarsa", seed=42)
ql_q, ql_returns = train("q_learning", seed=42)

window = 100
print("最后 100 回合平均回报:")
print(f"Sarsa: {sarsa_returns[-window:].mean():.2f}")
print(f"Q-learning: {ql_returns[-window:].mean():.2f}")
print("\nSarsa 贪婪策略:")
print(greedy_policy(sarsa_q))
print("\nQ-learning 贪婪策略:")
print(greedy_policy(ql_q))

CliffWalking 每走一步奖励为 −1-1,跌入悬崖奖励为 −100-100。Sarsa 的 TD 目标使用行为策略实际选择的 At+1A_{t+1},因此会把探索时跌落悬崖的风险计入价值,通常学到离悬崖更远的安全路径。Q-learning 的目标使用 max⁡a′Q(St+1,a′)\max_{a'}Q(S_{t+1},a'),倾向于学习贴近悬崖的最短路径;其贪婪策略回报更高,但训练期间的探索可能造成更大的负回报。单次随机实验不足以证明算法优劣,严谨比较应使用多个随机种子并报告均值与方差。

6. Q-learning 收敛性​

假设一个随机过程 {Δt}\{\Delta_t\} 的形式为:

Δt+1(x)=(1−αt(x))Δt(x)+αt(x)Ft(x)\Delta_{t+1}(x) = (1 - \alpha_t(x))\Delta_t(x) + \alpha_t(x)F_t(x)

如果满足以下条件,那么它将收敛到 0:

(1) ∑tαt(x)=∞\sum_t \alpha_t(x) = \infty,∑tαt2(x)<∞\sum_t \alpha_t^2(x) < \infty;

(2) ∥E[Ft(x)∣Ft]∥W≤γ∥Δt∥W\|\mathbb{E}[F_t(x)|\mathcal{F}_t]\|_W \leq \gamma \|\Delta_t\|_W,其中 γ<1\gamma < 1;

(3) Var[Ft(x)∣Ft]≤C(1+∥Δt∥W)2\text{Var}[F_t(x)|\mathcal{F}_t] \leq C(1 + \|\Delta_t\|_W)^2,其中 C>0C > 0 是一个常数。

在时间步 tt 给定一个数据 (st,at,rt,st+1)(s_t, a_t, r_t, s_{t+1}),Q-learning 的更新公式可以写成:

Qt+1(st,at)=Qt(st,at)+αt[st,at](rt+γmax⁡a′Qt(st+1,a′)−Qt(st,at))Q_{t+1}(s_t, a_t) = Q_t(s_t, a_t) + \alpha_t[s_t, a_t]\left(r_t + \gamma \max_{a'} Q_t(s_{t+1}, a') - Q_t(s_t, a_t)\right)

其中,更新步长 αt\alpha_t 与时间有关,并且满足 ∑tαt=∞\sum_t \alpha_t = \infty,∑tαt2<∞\sum_t \alpha_t^2 < \infty。我们将其重写成以下形式:

Qt+1(st,at)=(1−αt)Qt(st,at)+αt(rt+γmax⁡a′Qt(st+1,a′))Q_{t+1}(s_t, a_t) = (1 - \alpha_t)Q_t(s_t, a_t) + \alpha_t\left(r_t + \gamma \max_{a'} Q_t(s_{t+1}, a')\right)

假设 Q∗Q^* 是最优动作价值函数,令 Δt=Qt−Q∗\Delta_t = Q_t - Q^*。在上式等号左右两边减去 Q∗Q^*,然后令 Ft=rt+γmax⁡a′Qt(st+1,a′)−Q∗(st,at)F_t = r_t + \gamma \max_{a'} Q_t(s_{t+1}, a') - Q^*(s_t, a_t),于是有:

Δt+1(st,at)=(1−αt)Δt(st,at)+αtFt\Delta_{t+1}(s_t, a_t) = (1 - \alpha_t)\Delta_t(s_t, a_t) + \alpha_t F_t

基于环境状态转移的概率分布,可以求得其期望值为:

E[Ft∣Ft]=rt+γE[max⁡a′Qt(st+1,a′)]−Q∗(st,at)\mathbb{E}[F_t|\mathcal{F}_t] = r_t + \gamma \mathbb{E}[\max_{a'} Q_t(s_{t+1}, a')] - Q^*(s_t, a_t)

定义 Bellman 最优算子 T\mathcal{T}:

(TQ)(s,a)=E[rt+γmax⁡a′Q(st+1,a′)∣st=s,at=a](\mathcal{T}Q)(s,a) = \mathbb{E}[r_t + \gamma \max_{a'} Q(s_{t+1}, a') | s_t = s, a_t = a]

于是有:

E[Ft∣Ft]=(TQt)(st,at)−Q∗(st,at)\mathbb{E}[F_t|\mathcal{F}_t] = (\mathcal{T}Q_t)(s_t,a_t) - Q^*(s_t,a_t)

对于最优动作函数 Q∗Q^*,根据定义,它满足 Bellman 最优方程:

Q∗=TQ∗Q^* = \mathcal{T}Q^*

所以:

E[Ft∣Ft]=(TQt)(st,at)−(TQ∗)(st,at)\mathbb{E}[F_t|\mathcal{F}_t] = (\mathcal{T}Q_t)(s_t,a_t) - (\mathcal{T}Q^*)(s_t,a_t)

可以证明 T\mathcal{T} 是一个 γ\gamma-压缩算子,所以有:

∥E[Ft∣Ft]∥∞≤γ∥Qt−Q∗∥∞=γ∥Δt∥∞\|\mathbb{E}[F_t|\mathcal{F}_t]\|_\infty \leq \gamma \|Q_t - Q^*\|_\infty = \gamma \|\Delta_t\|_\infty

接下来,根据随机近似理论,我们可以进一步推导方差条件。因为奖励函数 rtr_t 是有界的,所以存在一个常数 CC,使得:

Var[Ft∣Ft]≤C(1+∥Δt∥∞)2\text{Var}[F_t|\mathcal{F}_t] \leq C(1 + \|\Delta_t\|_\infty)^2

因此,根据引理,Δt\Delta_t 能收敛到 0,这意味着 QtQ_t 能够收敛到 Q∗Q^*。