StarX

9 Actor-Critic及其变种

Sat, 08 Aug 2026 16:00:00 GMT

1. 引言：值函数与策略梯度的结合

首先回顾两种方法：

一、基于值函数的方法：以 DQN 为代表.它的核心思想是学到一个最优动作价值函数 $Q^*(s,a)$，但是它处理 连续动作空间 比较困难.当动作是一个连续向量时，每一步都要求解一个极值问题 $\max_a Q(s,a)$，这在计算上比较昂贵的，往往需要额外的优化过程.

二、基于策略梯度的方法：以 REINFORCE 为代表.它并不学习价值函数，而是直接参数化策略 $\pi_\theta(a\mid S)$，通过 Monte Carlo 采样的方式更新参数 $\theta$：

$$ \theta \leftarrow \theta + \alpha G_t \nabla_\theta \log \pi_\theta(A_t|S_t) $$

REINFORCE 方法能轻松处理连续动作，且天然具有随机探索的性质，但具有高方差的痛点，因为它的回报 $G_t$ 是整个 episode 所有奖励的累积和，轨迹长度的随机性和环境奖励的随机性，使得每次更新的方向波动巨大）

从直觉上来看，值函数方法它能够较好地评估策略，但不擅长行动，而策略梯度能够很好地给出行动，但评估自身价值比较困难，那么将两者结合起来，值函数方法作为评论家，策略梯度方法作为演员（行动者），让评论家帮助演员评估当前行为的好坏，从而减少策略梯度的方差.

Actor-Critic

Actor：策略 $\pi_\theta$，负责选择动作.它的更新依然沿着策略梯度的方向，但不再直接用高方差的回报 $G_t$，而是用一个低方差的、由 Critic 提供的信号.
Critic：价值函数，如 $V_{w}(s)$ 或 $Q_{w}(s,a)$，负责近似评估当前策略的预期收益

例子1：演员与评委的比喻
想象一个年轻演员 (Actor) 在学习演一出戏.一开始，他每次完整演完一场 (episode)，才由最终票房 (总回报 $G_t$) 来评判演技.票房受太多因素影响，有时演得好但票房差，信号极不稳定.这就像 REINFORCE.
现在引入一位资深评委 (Critic).演员每说一句台词、每做一个动作，评委都能立刻给出一个反馈：“这个动作的价值大概是 8 分，你刚才只表现出了 5 分的水平”.评委的评分不是最终真理 (有偏差)，但它很稳定 (低方差).演员根据这个即时反馈来调整自己的表演参数，进步就快得多了.这就是 Actor-Critic.

2. Actor-Critic 的基本架构与更新规则

2.1 在线策略 AC 方法

策略梯度定理 告诉我们：

$$ \nabla_\theta J(\theta) \propto \mathbb{E}{S\sim\mu,A\sim\pi} \left[ \nabla\theta \log \pi_\theta(A\mid S) , Q_{\pi}(S, A) \right]\tag{2.1} $$

其中 $Q_{\pi}(S_t, A_t)$ 是真实的动作价值函数.策略梯度方法的基本思想是通过最大化一个目标函数 $J(\theta)$ 来得到最优策略，通过梯度上升算法得到

$$ \begin{aligned} \theta_{t+1} & = \theta_t +\alpha\nabla_\theta J(\theta_t) \ & = \theta_t +\alpha \mathbb{E}{S\sim\mu,A\sim\pi} \left[ \nabla\theta \log \pi_\theta(a\mid S) , Q_{\pi}(S, A) \right]. \end{aligned} $$

进而通过随机梯度上升得到

$$ \theta_{t+1}=\theta_t +\alpha\nabla_{\theta}\log \pi(a_t \mid s_t,\theta_t)Q_t(s_t,a_t) $$

根据这一式子进行更新，我们需要知道 $Q_t(s_t,a_t)$，这是动作值 $Q_\pi(s_t,a_t)$ 的估计量.

估计动作值 $Q_t(s_t,a_t)$ 的方法
1. 若 $Q_t(s_t,a_t)$ 通过 Monte Carlo 方法估计，即 REINFORCE：使用采样回报 $G_t$ 作为 $Q_{\pi}$ 的无偏但高方差的估计.
2. 若 $Q_t(s_t,a_t)$ 通过时序差分方法估计，即本章的 Actor-Critic：利用 Critic 去估计 $Q_\pi$.

那么我们便得到的一般 Actor-Critic 算法伪代码：

$$ \begin{aligned} &\textbf{初始化：} \ &\quad \text{策略函数 } \pi(a|s,\theta_0),\text{价值函数 } q(s,a,w_0),;\alpha_w,\alpha_\theta>0 \ &\textbf{目标：} \text{最大化 } J(\theta) \ &\textbf{循环，每个回合中时间步 } t:\ &\quad a_t \sim \pi(a|s_t,\theta_t) \ &\quad \text{环境交互得到奖励 } r_{t+1},\text{下一状态 } s_{t+1} \ &\quad a_{t+1} \sim \pi(a|s_{t+1},\theta_t) \ &\quad \textbf{Actor (策略更新)}: \ &\quad \theta_{t+1} = \theta_t + \alpha_\theta \nabla_\theta \log \pi(a_t|s_t,\theta_t),q(s_t,a_t,w_t) \ &\quad \textbf{Critic (价值更新)}: \ &\quad w_{t+1} = w_t + \alpha_w \big[r_{t+1} + \gamma q(s_{t+1},a_{t+1},w_t) - q(s_t,a_t,w_t)\big] \nabla_w q(s_t,a_t,w_t) \end{aligned} $$

在更新参数 $\theta$ 时，可使用 TD 误差 $\delta_t$ 代替 $Q(s_t,a_t,w_t)$ 作为轨迹回报的估计

$$ \delta_t = r_{t+1}+\gamma Q_t(s_{t+1},a_{t+1},w_t)-Q_t(s_t,a_t,w_t) $$

对应的 Actor 更新变为

$$ \theta_{t+1}=\theta_t+\alpha_{\theta} \delta_t \nabla_{\theta}\log \pi(a_t\mid s_t,\theta_t) $$

这在减少计算量和减少方差方面有一定的优势.

一般 AC 算法通过单一的 Critic 的信号 TD 误差 $\delta_t$ 同时驱动了两个网络的更新.

2.2 离线策略 AC 方法

由于在线策略方法对环境的探索能力有限，可考虑离线策略方法：使用行为策略 $\beta(a\mid s)$ 来采样生成轨迹，并基于此轨迹来对目标策略 $\pi(a\mid s,\theta)$ 进行评估和改进.

离线策略环境中，对应的目标函数为

$$ \begin{aligned} J(\theta) & =\sum_{s\in\mathcal{S}}d_{\beta}(s)V_{\pi}(s)=\mathbb{E}{S\sim d{\beta}}[V_{\pi}(S)] \ & = \sum_{s\in\mathcal{S}}\sum_{a\in\mathcal{A}} d_{\beta}(s) \pi_{\theta}(a\mid s)Q_{\pi}(s,a), \end{aligned} $$

其中 $d_{\beta}(s)$ 是在策略 $\beta$ 下的平稳分布.那么 $J(\theta)$ 表示利用策略 $\beta(a\mid s)$ 采样的数据，评估策略 $\pi(a\mid s,\theta)$.

[!note] (Off-policy 策略梯度定理) 若 $\gamma\in(0,1)$，则 $J(\theta)$ 的 Off-policy 梯度为

$$\nabla_{\theta} J(\theta)=\mathbb{E}{S \sim \rho, A \sim \beta}\bigg [\underbrace{\frac{\pi(A \mid S, \theta)}{\beta(A \mid S)}}{\text {重要性权重 }} \nabla_{\theta} \log \pi(A \mid S, \theta) Q_{\pi}(S, A)\bigg ],$$

其中状态分布 $\rho$ 为

$$\rho(s)\doteq \sum_{s'\in \mathcal{S}}d_{\beta}(s')\mathrm{Pr}_{\pi}(s\mid s'),\quad s\in \mathcal{S},$$

以及 $\mathrm{Pr}{\pi}\left(s \mid s'\right)=\sum{k=0}^{\infty} \gamma^{k}\left[P_{\pi}^{k}\right]{s' s}=\left[\left(I-\gamma P{\pi}\right)^{-1}\right]_{s' s}$ 是在策略 $\pi$ 下从 $s'$ 到 $s$ 的折扣总概率.

[!note]- Off-policy 策略梯度定理证明：

$\rho_{\beta}$ 独立于 $\theta$，则 $J(\theta)$ 的梯度满足

$$ \nabla_{\theta}J(\theta)=\nabla_{\theta}\sum_{s\in\mathcal{S}}\rho_{\beta}(s)V_{\pi}(s)=\sum_{s\in\mathcal{S}}\rho_{\beta}(s)\nabla_{\theta}V_{\pi}(s). $$

$\nabla_{\theta}V_{\pi}(s)$ 的表达式为

$$ \nabla_{\theta}V_{\pi}(s)=\sum_{s'\in \mathcal{S}}\mathrm{Pr}{\pi}(s'\mid s)\sum{a\in \mathcal{A}}\nabla_{\theta}\pi (a\mid s',\theta)Q_{\pi}(s',a), $$

带入得

$$\begin{aligned}\nabla_{\theta} J(\theta) &=\sum_{s \in \mathcal{S}} d_{\beta}(s) \nabla_{\theta} v_{\pi}(s) \ & = \sum_{s \in \mathcal{S}} d_{\beta}(s) \sum_{s' \in \mathcal{S}} \operatorname{Pr}{\pi}\left(s' \mid s\right) \sum{a \in \mathcal{A}} \nabla_{\theta} \pi\left(a \mid s', \theta\right) Q_{\pi}\left(s', a\right) \& =\sum_{s' \in \mathcal{S}}\left(\sum_{s \in \mathcal{S}} d_{\beta}(s) \operatorname{Pr}{\pi}\left(s' \mid s\right)\right) \sum{a \in \mathcal{A}} \nabla_{\theta} \pi\left(a \mid s', \theta\right) Q_{\pi}\left(s', a\right) \& \doteq \sum_{s' \in \mathcal{S}} \rho\left(s'\right) \sum_{a \in \mathcal{A}} \nabla_{\theta} \pi\left(a \mid s', \theta\right) Q_{\pi}\left(s', a\right) \& =\sum_{s \in \mathcal{S}} \rho(s) \sum_{a \in \mathcal{A}} \nabla_{\theta} \pi(a \mid s, \theta) Q_{\pi}(s, a) \quad\left(\text { 将 } s' \text { 换为 } s\right) \& =\mathbb{E}{S \sim \rho}\left[\sum{a \in \mathcal{A}} \nabla_{\theta} \pi(a \mid S, \theta) Q_{\pi}(S, a)\right].\end{aligned}$$

利用重要性采样得到 $$\begin{aligned}&\mathbb{E}{S\sim\rho}\left[\sum{a\in\mathcal{A}}\nabla_{\theta}\pi(a\mid S,\theta)Q_{\pi}(S,a)\right] \ =& \mathbb{E}{S\sim\rho}\left[\sum{a\in\mathcal{A}}\beta(a\mid S)\frac{\pi(a\mid S,\theta)}{\beta(a\mid S)}\frac{\nabla_{\theta}\pi(a\mid S,\theta)}{\pi(a\mid S,\theta)}Q_{\pi}(S,a)\right] \=&\mathbb{E}{S\sim\rho}\left[\sum{a\in\mathcal{A}}\beta(a\mid S)\frac{\pi(A\mid S,\theta)}{\beta(a\mid S)}\nabla_{\theta}\log\pi(a\mid S,\theta)Q_{\pi}(S,a)\right] \ = &\mathbb{E}{S\sim\rho,A\sim\beta}\left[\frac{\pi(A\mid S,\theta)}{\beta(A\mid S)}\nabla{\theta}\log\pi(A\mid S,\theta)Q_{\pi}(S,A)\right]\end{aligned}$$

在 Off-policy 演员-评论家算法中，使用行为策略 $\beta(a\mid s)$ 生成采样轨迹，Actor 与 Critic 均使用重要性采样比例 $\dfrac{\pi_{\theta}(a\mid s)}{\beta(a\mid s)}$ 进行调整，利用随机梯度上升得到

$$ \theta_{t+1}=\theta_t+\alpha_\theta\frac{\pi(a_t|s_t,\theta_t)}{\beta(a_t|s_t)}\nabla_\theta\log\pi(a_t|s_t,\theta_t)Q_t(s_t,a_t) $$

和

$$ w_{t+1}=w_t+\alpha_w \frac{\pi(a_t\mid s_t,\theta_t)}{\beta(a_t\mid s_t)}\delta_t\nabla_w Q_t(s_t,a_t,w_t), $$

其中

$$ \delta_t=r_{t+1}+\gamma Q_t(s_{t+1},a_{t+1},w_t)-Q_t(s_t,a_t,w_t). $$

3. 理论与意义：偏差-方差的权衡与兼容性

3.1 自举引入的偏差与方差的降低

将 REINFORCE (MC critic) 替换为 TD Critic，实际上做了一次偏差-方差的权衡：

REINFORCE 是无偏的，它使用的是真实的环境回报 $G_t$，但方差高.
Actor-Critic 使用 $R + \gamma V(S')$ 作为目标.这里的 $V$ 是带有误差的估计，因此更新目标是有偏的.但这一替换将方差源头从“整个轨迹的随机奖励”缩减到“单步奖励和下一状态价值估计”，使得方差降低.

3.2 兼容近似定理

策略梯度定理告诉我们： $$ \nabla_\theta J(\theta) \propto \mathbb{E}{S\sim\mu,A\sim\pi} \left[ \nabla\theta \log \pi_\theta(a\mid S) , Q_{\pi}(S, A) \right] $$ 在 AC 算法中，存在一个重要的理论问题：当我们用一个参数化的近似函数 $Q_w$ 来替代真实的 $Q_\pi$ 时，策略梯度会不会被带偏？

Sutton 等人的策略梯度定理告诉我们，只要近似函数满足兼容性条件，那以上替换不会引入偏差：

近似函数可以写成

$$ Q_w(s,a)=w^{T}\nabla_{\theta}\log \pi_{\theta}(a\mid s)+b(s) $$

参数 $w$ 通过最小化与真实 $Q_{\pi}$ 的均方误差来学习：

$$ w^*=\arg\min_{w}\mathbb{E}{S\sim \mu,A\sim \pi}\big [(Q_w(S,A)-Q{\pi}(S,A))^2\big ] $$

若近似函数满足以上兼容性条件，那么用 $Q_w$ 替换 $Q_{\pi}$ 计算出的策略梯度是真是梯度的无偏估计：
$$ \mathbb{E}[\nabla_{\theta}\log \pi_{\theta}(A\mid S)Q_w(S,A)]=\mathbb{E}[\nabla_\theta\log\pi_{\theta}(A\mid S)Q_{\pi}(S,A)] $$

[!note]- 兼容近似定理证明：

$w$ 满足条件 2，令 $\epsilon\doteq Q_w(s,a)-Q_\pi(s,a)$，则 $\nabla_w\epsilon=\nabla_w Q_w(s,a)=0$.进一步有 $\mathbb{E[\epsilon\nabla_w \epsilon]}=0$.

$w$ 满足条件 1，则 $\nabla_w Q_w(s,a)=\nabla_\theta\log\pi_{\theta}(a\mid s)=0$.有

$$\begin{aligned}0=\mathbb{E}[\epsilon\nabla_w\epsilon] & = \mathbb{E}[(Q_w(S,A)-Q_\pi(S,A))\nabla_w Q_w(S,A)]\& = \mathbb{E}[(Q_w(S,A)-Q_\pi(S,A))\nabla_\theta\log\pi_{\theta}(A\mid S)]\end{aligned}$$

即

$$\mathbb{E}[Q_\pi(S,A)\nabla_\theta\log\pi_{\theta}(A\mid S)]=\mathbb{E}[Q_w(S,A)\nabla_\theta\log\pi_{\theta}(A\mid S)]$$

在实践中，即使不完全满足，只要 Critic 用策略指导下的真实样本进行 TD 学习，即条件 2 被放宽，算法也能良好收敛.
如果两个条件同时满足，整个 AC 算法实际上变成了 REINFORCE 算法，即等同于没有使用评论家 Critic.

4. Actor-Critic 变种：A2C

4.1 Advantage Actor-Critic (A2C)

同 REINFORCE 方法，AC 方法可以采用引入基线的方式进一步减小方差：

$$ \nabla_\theta J(\theta) \propto \mathbb{E}{S\sim\mu,A\sim\pi} \left[ \nabla\theta \log \pi(A\mid S,\theta) , (Q_{\pi}(S, A) - b(S)) \right] $$

基准不变性

$$ \mathbb{E}{S\sim\mu,A\sim\pi}\left[\nabla{\theta}\log \pi(A\mid S,\theta)Q_\pi(S,A)\right]=\mathbb{E}{S\sim\mu,A\sim\pi}\left[\nabla{\theta}\log \pi(A\mid S,\theta)(Q_\pi(S,A)-b(S))\right], $$

其中 $b(S)$ 是关于 $S$ 的一个基准标量函数.

$$ \begin{aligned} & \mathbb{E}{S \sim \mu, A \sim \pi}\left[\nabla{\theta} \log \pi\left(A \mid S, \theta\right) b(S)\right] \ = & \sum_{s \in \mathcal{S}} \mu(s) \sum_{a \in \mathcal{A}} \pi\left(a \mid s, \theta\right) \nabla_{\theta} \log \pi\left(a \mid s, \theta\right) b(s) \ = & \sum_{s \in \mathcal{S}} \mu(s) \sum_{a \in \mathcal{A}} \nabla_{\theta} \pi\left(a \mid s, \theta\right) b(s) \ = & \sum_{s \in \mathcal{S}} \mu(s) b(s) \sum_{a \in \mathcal{A}} \nabla_{\theta} \pi\left(a \mid s, \theta\right) \ = & \sum_{s \in \mathcal{S}} \mu(s) b(s) \nabla_{\theta} \sum_{a \in \mathcal{A}} \pi\left(a \mid s, \theta\right) \ = & \sum_{s \in \mathcal{S}} \mu(s) b(s) \nabla_{\theta} 1=0 . \end{aligned} $$

基准函数的引入
基准函数能够在使用随机样本近似真实梯度时 减少近似的方差.

定义

$$ X(S,A)\doteq\nabla_{\theta}\log \pi(A\mid S,\theta)(Q_{\pi}(S,A)-b(S)). $$

我们的目标是选择基准函数 $b(S)$，使得方差 $\mathrm{var}(X)$ 越小越好.实际上能够最小化 $\mathrm{var}(X)$ 的最优基准是

$$ b^{*}(s)=\frac{\mathbb{E}{A \sim \pi}\left[\left|\nabla{\theta} \log \pi\left(A \mid s, \theta\right)\right|^{2} Q_{\pi}(s, A)\right]}{\mathbb{E}{A \sim \pi}\left[\left|\nabla{\theta} \log \pi\left(A \mid s, \theta\right)\right|^{2}\right]}, \quad s \in \mathcal{S} $$

[!note]- 最优基准表达式证明：

选择迹作为优化的目标函数： $$\begin{aligned}\mathrm{tr}[\mathrm{var}(X)] & =\mathrm{tr}\mathbb{E}[(X-\bar{x})(X-\bar{x})^\mathrm{T}] \ & =\mathrm{tr}\mathbb{E}[XX^\mathrm{T}-\bar{x}X^\mathrm{T}-X\bar{x}^\mathrm{T}+\bar{x}\bar{x}^\mathrm{T}] \ & =\mathbb{E}[X^\mathrm{T}X-X^\mathrm{T}\bar{x}-\bar{x}^\mathrm{T}X+\bar{x}^\mathrm{T}\bar{x}] \& =\mathbb{E}[X^\mathrm{T}X]-\bar{x}^\mathrm{T}\bar{x},\end{aligned}$$

其中 $\bar{x}\doteq \mathbb{E}[X]$. 将 $X$ 的表示式带入 $\mathbb{E}[X^TX]$ 得

$$\begin{aligned}\mathbb{E}[X^{\mathrm{T}}X] & =\mathbb{E}\left[(\nabla_\theta\log\pi)^\mathrm{T}(\nabla_\theta\log\pi)(Q_\pi(S,A)-b(S))^2\right] \& =\mathbb{E}\left[|\nabla_\theta\log\pi|^2(Q_\pi(S,A)-b(S))^2\right]\& = \sum_{s\in \mathcal{S}}\eta(s)\mathbb{E}{A\sim\pi}[|\nabla{\theta}\log\pi|^2(Q_{\pi}(s,A)-b(S))^2].\end{aligned}$$

目标函数最优，则 $\nabla_b\mathbb{E}[X^TX]=0,\forall s\in\mathcal{S}$，进一步有

$$\mathbb{E}{A\sim\pi}[|\nabla{\theta}\log\pi|^2(Q_{\pi}(s,A)-b(S))]=0,$$

求解即得最优基准.

最优基准过于复杂，难以在实际中使用. 移除权重 $|\nabla_{\theta} \log \pi(A \mid s, \theta)|^{2}$，便得到一个次优的基准，即

$$ b^*(s)=\mathbb{E}{A\sim\pi}[Q{\pi}(s,A)]=V_\pi(s),\quad s\in\mathcal{S}. $$

那么令基准 $b(S) = V_{\pi}(S)$，于是得到了优势函数：

$$ A_{\pi}(s,a) = Q_{\pi}(s,a) - V_{\pi}(s) $$

优势函数衡量的是“在状态 $s$ 采取动作 $a$ 比平均水平好多少”.用它代替纯粹的 $Q$ 值，可以极大地降低梯度估计的方差，同时不引入偏差.

此时算法变为

$$ \begin{aligned} \theta_{t+1} & = \theta_t+\alpha\nabla_{\theta}\log \pi(a_t,\mid s_t,\theta_t)[Q_t(s_t,a_t)-V_t(s_t)]\ & = \theta_t+\alpha\nabla_{\theta}\log \pi(a_t,\mid s_t,\theta_t)A_t(s_t,a_t) \end{aligned} $$

评论家 Critic 部分是一个优势函数 $A$，其估计同样有两种方法：

若 $Q_t(s_t,a_t)$ 和 $V_t(s_t)$ 是通过 Monte Carlo 方法估计的，对应的便是带基准的 REINFORCE ；
若 $Q_t(s_t,a_t)$ 和 $V_t(s_t)$ 是通过时序差分方法估计的，对应的 AC 方法变为 Advantage Actor-Critic(A2C) 方法.此时需要两个近似函数，同时更新两套参数：
- 近似值函数：$V(s,v)\approx V_{\pi}(s)$ ;
- 近似行为值函数：$Q(s,a,w)\approx Q_{\pi}(s,a)$

实际操作中一般用 TD 误差代替优势函数进行计算，即

$$ Q_t(s_t,a_t)-V_t(s_t)\approx r_{t+1}+\gamma V_t(s_{t+1})-V_t(s_t), $$ 这是因为 TD 误差是优势函数的无偏估计：
$$

\begin{aligned} &\mathbb{E}[R_{t+1}+\gamma V_{\pi}(S_{t+1})-V_{\pi}(S_t) \mid S_t=s_t, A_t=a_t] \ = & \mathbb{E}[R_{t+1}+\gamma V_{\pi}(S_{t+1})\mid S_t=s_t,A_t=a_t]-V_{\pi}(s_t)\ = & Q_{\pi}(s_t,a_t)-V_{\pi}(s_t)\ = & A_{\pi}(s_t,a_t). \end{aligned} $$

此时只需要使用一个神经网络来表征 $V_{\pi}(s)$.

5 Actor-Critic 变种：A3C

5.1 异步方法的引入

在 DQN 中，我们利用经验放回的技巧来打破数据之间的相关性，但它也存在一些缺点：

每次交互都需要更多的内存和计算，因为在算法中我需要设置一个回放缓冲区，用来放存收集的经验样本；
探索效率低：一个智能体一次只能经历一个轨迹 $s_0\rightarrow s_1\rightarrow s_2\ldots$
e.g. 网格世界中，单个 agent 逐个探索路线 episode 1, episode 2...效率低下.

异步：每个 agent 独立运行

agent1 ---> 更新 ---> Global Network
agent2 ---> 更新 ---> Global Network
agent3 ---> 更新 ---> Global Network

通过在多个环境实例中并行地执行多个智能体，来产生多样化的数据.在给定的时间步，并行的智能体将经历各种不同状态，从而避免了数据之间的相关性.
不同经验共同训练，且可以有不同的探索策略，具备探索多样性，从而能够丰富训练数据

异步思想：

多 Worker 并行交互：在算法中启动多个独立的线程（Worker），每个 Worker 都有一份全局共享网络的副本（Local Network），并各自独立地与各自的环境实例进行交互，收集数据；
异步更新：多个 Worker 不需要等待，当某一 Worker 完成一定步数的梯度计算后，就立即推送到全局共享网络进行更新，再使用新的参数继续下一轮交互；
避免数据相关性，从而无需经验回放

类似于批量更新方式，单个 Worker 将固定时间步内的更新量进行累计，每隔一定时间步将累积的更新量更新到共享参数，可以减少多个 Worker 彼此覆盖的可能.

5.2 Asynchronous Advantage Actor-Critic (A3C)

异步优势演员-评论家算法(A3C)

A3C 在 A2C 的基础上引入异步方法，它维护一个全局网络和多个并行的 worker 线程，每个 worker 有自己独立的本地网络副本.worker 在各自的环境中独立运行、独立计算本地梯度，并异步地更新全局网络参数，然后再从全局网络拉取最新参数.

A3C 算法需要计算两个参数：

参数 $\theta$（Actor）：策略函数 $\pi(a_t\mid s_t,\theta)$；
参数 $\theta_v$（Critic）：值函数 $V(s_t;\theta_v)$.

对每一个 Worker:
初始化.同步全局参数至本地参数，得到自己独立的本地网络的环境θ'(Actor),θ_v'(Critic)

进行 Actor-Critic 本地模型训练
    得到初始化状态 s
    遵循策略 π(a | s;θ') 采样得到动作 a_t, 并与环境交互得到 r_t, s_{t+1}
    类似批量更新方式，缓存固定时间步（全局网络更新频率）内的轨迹
        达到全局网络更新条件（固定时间步或轨迹终止）：
            批量计算 TD 目标
            更新本地网络（Actor-Critic）

同步本地参数至全局参数

策略梯度定理

$$ \nabla_\theta J(\theta) \propto \mathbb{E}{S\sim\mu,A\sim\pi} \left[ \nabla\theta \log \pi_\theta(A\mid S) , Q_{\pi}(S, A) \right] $$

| 算法 | 参数更新公式 | 备注 | | -------------------------------- | ----------------------------------------------------------------------------------------------------------------- | ------------------------------------------- | | REINFORCE | $\theta \leftarrow \theta + \alpha , G_t , \nabla_\theta \log \pi_\theta(A_t \mid S_t)$ | $G_t$：从时刻 $t$ 开始的累计折扣回报 | | 带基准的 REINFORCE | $\theta \leftarrow \theta + \alpha , (G_t - V_w(s_t)) , \nabla_\theta \log \pi_\theta(A_t \mid S_t)$ | $G_t - V_w(s_t)$：引入状态值函数作为基准，降低方差 | | Actor-Critic (AC) | $\theta \leftarrow \theta + \alpha , \nabla_\theta \log \pi(a_t \mid s_t, \theta) , Q_t(s_t, a_t)$ | $Q_t(s_t, a_t)$ 动作值函数作为 Critic 的估计 | | A2C (Advantage Actor-Critic) | $\theta \leftarrow \theta + \alpha , \nabla_\theta \log \pi(a_t \mid s_t, \theta) , [Q_t(s_t, a_t) - V_t(s_t)]$ | $Q_t(s_t, a_t) - V_t(s_t)$：优势函数，用于减少方差并稳定训练 |

教材参考

邹伟 - 强化学习 - 清华大学出版社.

Richard S. Sutton - Reinforcement Learning: An Introduction.

6 资格迹

Thu, 09 Jul 2026 16:00:00 GMT

资格迹

前面我们学习了 TD 算法，它只根据眼前的即时奖励 $R_{t+1}$ 和下一状态的价值 $V(S_{t+1})$ 来调整自己的估计.

而我们的问题是，能不能再保留 TD 算法在线、低方差优点的同时，也拥有类似蒙特卡洛方法那样高效分配奖励的能力——资格迹

1. 回顾与动机：一步更新的局限

我们将之前所学习的 TD 算法记为 $\text{TD}(0)$，后面大家会明白这一符号的含义.在状态序列中，我们执行更新：

$$ V(S_t) \leftarrow V(S_t) + \alpha \big[ R_{t+1} + \gamma V(S_{t+1}) - V(S_t) \big], $$

它只利用紧接着的一步奖励来更新前一个状态的价值.这带来两个问题：

信息传播速度慢.当一个 episode 末尾才出现明显的奖励信号（比如走到终点获得 +1），$\text{TD}(0)$ 需要沿着经历的顺序，一个状态一个状态地把奖励信息往回“倒灌”，这个过程可能极其漫长.
信用分配的偏差.如果某一步的状态变动触发了后来一系列好的结果，但 $\text{TD}(0)$ 只把功劳或责任归给前一个状态，更早的状态需要多次重复经历才能获得公平的分配.

Monte Carlo 方法，需要等到 episode 结束后，用全部剩余奖励的折扣和 $G_t$ 来更新沿途的每一个状态： $$ V(S_t) \leftarrow V(S_t) + \alpha \big[ G_t - V(S_t) \big], $$ 其信息传播是“瞬间”的，整个轨迹上的所有状态同时获得更新.但它的代价是高方差——因为必须走完一个完整的 episode，奖励序列中的随机噪声全部累积了起来，且必须等 episode 结束才能学习，无法在线更新.

[!note]- 信息传播速度慢假设一个简单状态序列 $s_0$ → $s_1$ → $s_2$ → $s_3=\text{Goal}$，$r_1=r_2=0$， $r_3=1$. 终点状态 $V(s_3)=0$，折扣因子 $\gamma$，学习率 $\alpha$.

1）$\text{TD}(0)$

目的：对 $\pi$ 评估.初始化 $V(s)=0,\forall s$. 根据 TD 更新公式

episode 1：

$$\begin{aligned}& V(s_0)=V(s_1)=0,\& V(s_2)=0+\alpha[1+0\cdot 0]=\alpha.\end{aligned}$$

episode 2:

$$\begin{aligned}& V(s_0)=0,\ V(s_1)=0+\alpha[0+\gamma V(s_2)-0]=\alpha^2\gamma,\ & V(s_2)=\alpha+\alpha [1-\alpha]=2\alpha-\alpha^2.\end{aligned}$$

episode 3:

$$\begin{aligned}& V(s_0)=0+\alpha[0+\gamma V(s_1)-0]=\alpha^3\gamma^2, \& V(s_1)=\alpha^2\gamma+\alpha[\gamma(2\alpha-\alpha^2)-\alpha^2\gamma]=3\alpha^2\gamma-2\alpha^3 \gamma, \& V(s_2)=\ldots. \\end{aligned}$$

可以看到，每一个 episode 只传播一点.在 episode 1 中，想要更新 $s_0,s_1$ 的价值，只能等下一个 episode. 由于 $\text{TD}(0)$一次更新只看一步，它并不知道后面还有多远，因此 $\text{TD}(0)$的信息传播速度慢.

2）Monte Carlo

Monte Carlo 在一次 episode 结束后，知道整条轨迹的最终回报，其看到了每一步的奖励.针对上述序列问题，已知 $r_1,r_2,r_3$，那么可直接计算得到 $G_0,G_1,G_2$，从而得到各状态的价值，即 Monte Carlo 能更快地传播奖励信息

【注】信息传播速度快 $\neq$ 收敛速度快：$\text{TD}(0)$只利用一步信息，若环境随机，则更新时只受一步随机性的影响；而 Monte Carlo 依赖整条轨迹，任何一步随机变化都会影响，每次更新存在较大方差，使得更新可能一直剧烈震荡.TD 由于单步地逐步学习，后续状态价值会越来越稳定，更新波动会小很多，因而一般情况下收敛更稳定，收敛速度更快.但若为确定性环境，如上述的确定状态序列，明显 Monte Carlo 的收敛速度更快.

[!note]- 信用分配的偏差 偏差： 指代作用权重、资格分配不完整.

假设一个简单状态序列 $s_0$ → $s_1$ → $s_2$ → $s_3=\text{Goal}$，$r_1=r_2=0$， $r_3=1$. 终点状态 $V(s_3)=0$，折扣因子 $\gamma$，学习率 $\alpha$.

$\text{TD}(0)$

episode 1: $V(s_0)=V(s_1)=0,V(s_2)=\alpha$，即 $s_0,s_1$ 没有奖励，没有贡献，$s_2$ 得到奖励，有贡献. 但这样的表述明显不对：正是由 $s_1\to s_2$，$s_2$ 才能到达 $s_3$，同样地有 $s_0\to s_1$.由此出现了短暂的、不完整的分配.

原因： $\text{TD}(0)$ 只看到了下一步，如对于 $s_0$ 来说不知道再走两步便到达 Goal.

$\text{TD}(0)$：第一次只奖励 $s_2$，第二次奖励 $s_1$，第三次奖励 $s_0$，因此更早的状态需要多次重复经历才能获得更完整公平的信用分配.

Monte Carlo

整个 episode 结束后，知道最终到达 Goal（$s_3$），且知道每一步奖励，可以直接计算每个状态真正经历得到的回报.

对于 Monte Carlo 来说，其所谓的高效分配，即是对轨迹中的状态，按照之后真正获得的累计回报来分配直观上，$s_2$ 距 Goal($s_3$)最近，价值最大，$s_1$ 可以到达距离 Goal 更近的 $s_2$，也有价值，而 $s_0$ 虽然距 Goal 远，但最终还是可以到到 Goal，因此也分配一定的价值.

| | $\text{TD}(0)$ | Monte Carlo | | :-: | :----------: | :-----------------------: | | 优 | 在线，更新及时，低方差 | 高效分配奖励，信息传播快 | | 劣 | 分配奖励低效，信息传播慢 | 需等待 Episode 结束，高方差，样本利用率低 |

于是，一个自然的想法出现了：能不能在每一步都进行更新，但更新的幅度不仅仅影响当前状态的前一个状态，而是根据某种“责任资格大小”，把当前观察到的 TD 误差扩散到之前访问过的多个状态上？

这就是资格迹要解决的核心问题.

2. 前向视角：λ回报——多步回报的加权融合

在引入资格迹的机制之前，我们先从前向视角（或称理论视角）来看理想的目标是什么.

我们已经知道 $\text{TD}(0)$ 的目标是 1 步回报：

$$ G_t^{(1)} = R_{t+1} + \gamma V(S_{t+1}). $$

蒙特卡洛的目标是无穷步回报 $G_t$，即在终止前累积的真实奖励.那么，介于两者之间的便是 $n$ 步回报：

$$ G_t^{(n)} = R_{t+1} + \gamma R_{t+2} + \dots + \gamma^{n-1} R_{t+n} + \gamma^n V(S_{t+n}). $$

$n$ 步回报既含有 $n$ 步的真实奖励，又以 $n$ 步后状态的当前价值作为剩余回报的估计.

$n=1$ 时，方差小，有偏；
$n=2$ 时，多了一步真实奖励；
$n=3$ 时，真是奖励更多，估计值更少. 因此，随着 $n$ 增加，一般情况下偏差减小，方差增大.

我们可以选择任何一个 $n$ 作为更新的目标，但不一定只选一个固定的 $n$，因此我们可以采用不同 $n$ 值的线性组合对参数进行更新，并使它们的权重值和为 $1$. 根据这样的思路，便产生一种特定权重的分配方式，即 $\text{TD}(\lambda)$前向算法（λ-回报算法）.

λ-回报 的做法是，对所有的 $n$ 步回报做一个指数衰减的加权平均：

$$ G_t^\lambda = (1-\lambda) \sum_{n=1}^{\infty} \lambda^{n-1} G_t^{(n)}, $$

此时中间的 $\lambda$ 值让我们在偏差和方差之间连续调节：$\lambda$ 越小，更多依赖有偏但低方差的 TD 估计；$\lambda$ 越大，更多依赖无偏但高方差的实际奖励.

当轨迹为有限 $T$ 步时，此时

$$ G_t^{\lambda}=(1-\lambda)\sum_{n=1}^{T-t-1} \lambda^{n-1}G_t^{(n)}+\lambda^{T-t-1}G_t. $$

这里，$\lambda \in [0,1]$.当 $\lambda=0$ 时，$G_t^\lambda = G_t^{(1)}$，退化为 $\text{TD}(0)$；当 $\lambda=1$ 时，为 Monte Carlo 回报 $G_t$（在 episodic 情况下，并假设对终止状态 $V=0$）.最终我们得到 TD 目标，可以进行值函数更新：

$$ V(S_{t})\leftarrow V(S_t)+\alpha (G_t^{\lambda}-V(S_t)). $$

前向视角对于每个访问到得状态 $s$，从它开始向前看所有得未来状态，并决定如何结合未来状态得回报来更新当前状态 $s$ 的值函数 $V(S_t)$ .每更新完当前状态 $s$，就转移至下一状态 $s'$，且不再回头关心已更新的状态 $s$.也就是说，前向视角是通过观看未来状态的回报估计当前状态的值函数.

[!note]- 例 1：状态随机游走想象一排 21个状态，从左端 -10 走到右端 +10，每步等概率向左或向右，到达两端 episode 终止，奖励只有到达 +10 时 +1，其他 0.

如果采用 $\text{TD}(0)$（λ=0），价值信息必须从终点逐步向相邻状态传播.在 100 个 episode 训练后，远离终点的状态价值依然接近 0.

如果采用 MC（λ=1），每个 episode 结束后，整条路径上的状态都根据最终奖励更新，信息瞬间传遍，但因每个 episode 路径长度差异大，方差很高，学习曲线震荡剧烈.

取一个中间值，如 λ=0.5 或 0.7，能用明显更少的 episode 达到更低的均方根误差.这就是 λ-回报的优势：结合两者优势，加速学习.

然而，从实现角度看，λ回报要求我们在 episode 结束时才能计算，因为 $G_t^\lambda$ 依赖于未来的奖励和状态价值，这显然不是一种在线、逐步更新的算法.那么，有没有一种方式能在每一步立即进行更新，却等价于前向的 λ-回报？答案就是资格迹.

3. 资格迹的引入：TD(λ) 后向视角

由于前向视角在估计值函数时，每一个时间步都需要用到很多步之后的信息，在工程上十分不高效.我们需要一种无需等到实验结束就可以更新当前状态的值函数更新方法.

资格迹提供了一种后向视角：我们不再等着未来回报再去平均，而是每经历一步，立即计算 TD 误差 $\delta_t$，然后把这个误差分配给过去访问过的所有状态，分配的比例由一个称为资格迹的变量 $E_t(s)$ 决定.

直觉上，一个状态如果最近经常被访问，它就更“有资格”接受当前的 TD 误差的更新.资格迹更新方式如下 $E_0(s)=0$：

$$ E_t(s) = \begin{cases} \gamma \lambda E_{t-1}(s) + 1, & s = S_t, \ \gamma \lambda E_{t-1}(s), & s \neq S_t. \ \end{cases} $$

其被称为 累积型资格迹，表示 $t$ 时刻状态 $s$ 对应的资格迹，其含义是：

每当一个状态被访问，它的迹增加 1（“被访问则给它加上一份资格”）.
之后，所有状态的迹都按原来 $\gamma \lambda$ 的速率衰减（“随着时间的流逝，过去状态的资格逐渐消退”）.
$\gamma$ 是折扣因子；$\lambda$ 控制衰减的速度，称迹退化参数.$\lambda$ 越小，迹消失得越快，更新就越集中在最近的状态；$\lambda$ 越大，迹越持久，更新越接近均匀地分配给所有过去状态.

$\text{TD}(\lambda)$ 的更新为：

$$ \delta_t = R_{t+1} + \gamma V_t(S_{t+1}) - V_t(S_t), $$

$$ V_{t+1}(s) = V_t(s) + \alpha \delta_t E_t(s), \quad \forall s. $$

也就是说，每一步的 TD 误差，都按照当前每个状态的资格迹权重来，更新其价值.那些最近被访问、且 $\lambda$ 较大的状态，会获得较大的更新幅度；很久以前的状态迹已经衰减殆尽，几乎不会被更新.

特别地，$\lambda=0$ 时，即 $\text{TD}(0)$，此时资格迹为

$$ E_t(s) = \begin{cases} 1, & s = S_t, \ 0 & s \neq S_t. \ \end{cases} $$

更新变为

$$ \begin{cases} V_{t+1}(s) = V_t(s) + \alpha \delta_t, & s=S_t, \ V_{t+1}(s)=V_t(s), & s\neq S_t, \ \end{cases} $$

即一个 TD 误差 $\delta_t$ 只更新当前状态 $S_t$.

[!note]- 例 2：简单状态序列的迹演化假设一个简单状态序列 $s_0$ → $s_1$ → $s_2$ → $s_3=\text{Goal}$ .折扣因子 $\gamma$，迹退化参数 $\lambda$，初始化所有 $V=0$，迹为 $0$.

从 $s_0$ 到 $s_1$，迹 $E(s_0)$ =1，其它为 $0$.计算 $\delta_0$ ，此时仅更新 $V(s_0)$.

从 $s_1$ 到 $s_2$，$E(s_0)$ 衰减为 $\gamma\lambda$，$E(s_1)=1$，计算 $\delta_1$ ，此时更新 $V$ 会同时影响 $s_0$ 和 $s_1$，但 $s_0$ 的影响权重小于 $s_1$.

从 $s_2$ 到 $s_3$，$E(s_0)=(\gamma\lambda)^2$，$E(s_1)=\gamma\lambda$，$E(s_2)=1$.此时到达终点 $s_3$ 获得 $+1$ 奖励，误差 $\delta_2$ 较大.该误差会依据迹的权重同时更新 $s_0,s_1,s_2$，$s_0$ 因衰减系数得到较小的更新，$s_2$ 得到较大的更新.

另一方面，在 $\text{TD}(0)$ 中，每一步只更新当前状态，到达终点时，得到 $+1$ 奖励与误差 $\delta_2$，但只有 $s_3$ 的前一个状态 $s_2$ 被更新，而要更新 $s_0$ 需要很多次重复经历.资格迹正好弥补了这一缺陷.

$\text{TD}(\lambda)$资格迹分配：越近期的状态，对当前 TD 误差贡献越直接，因此获得更多更新；越早的状态，虽然贡献较小，但仍然能立即获得部分奖励，而不需要等待多个 episode.

4. 资格迹的变种：替换迹与其他

累积型资格迹中

$$ E_t(s) = \begin{cases} \gamma \lambda E_{t-1}(s) + 1, & s = S_t, \ \gamma \lambda E_{t-1}(s), & s \neq S_t. \ \end{cases} $$

$\gamma \lambda E_{t-1}(s)$ 代表频率启发式，指将资格分配给较频繁的状态；示性函数 $I_{sS_t}$ 代表最近启发式，指将资格分配个给最近的状态.在状态被反复快速访问时，可能会使得迹过大，导致更新过度.一种常用的改进是替代型资格迹，其更新规则变为：

$$ E_t(s) = \begin{cases} \gamma \lambda E_{t-1}(s), & s \neq S_t, \ 1, & s = S_t, \end{cases} $$

即每次进入一个状态时，直接将其迹重置为 1，而不是累加.这避免了某些被循环访问的状态迹值无限制增长，通常在部分可观测或频繁重复访问的状态空间中效果更优.

5. 前向算法与后向算法的统一

前向视角与后向视角在更新值函数时采用的方式不同：前向视角需要等到一次 episode 结束后更新当前状态的值函数，更新完当前状态的值函数后，此状态的值函数就不再改变；后向视角不需要等到轨迹结束，在每个时间步计算完当前状态的 TD 误差后，其它状态的值函数需要利用当前状态的 TD 误差进行更新.它在每个时间步都在进行值函数更新，是增量式更新方法.

资格迹后向更新的 $\text{TD}(\lambda)$ 为什么能做到与离线的前向 λ 回报等价？

设想我们把一个 episode 所有步的更新累加起来.后向视角的在线更新在每步使用该时刻的 $V$值，而前向视角在所有数据已知后统一计算.当 α 足够小（或采取离线更新，即在 episode 结束后一次性应用所有 δ 但保持过程中 V 不变），两种视角在总量上完全等价.

等价的关键在于，每个奖励 $R_{t+k}$ 对某个状态价值估计的贡献，通过迹机制恰好以权重 $(\gamma\lambda)^{k-1}$ 分配到 k 步之前的状态，这与 λ 回报中 n 步回报的加权系数完美匹配.因此：

$$ \sum_{t} \alpha \delta_t E_t(s) \quad \text{等价于} \quad \alpha \big( G_s^\lambda - V(s) \big). $$

这说明 $\text{TD}(\lambda)$ 本质上就是在一步步实现对 λ 回报的逼近，但以一种真正的在线、增量式、内存高效的方式完成.这也是资格迹被称为强化学习“时间桥梁”的原因.

[!note]- 前向视角中 $\lambda$ 权重的分配与前后向视角的统一在 $\text{TD}(\lambda)$的前向视角中，定义了 $\lambda$ -回报为所有 $n$ 步回报的加权平均

$$G_t^\lambda = (1-\lambda) \sum_{n=1}^{\infty} \lambda^{n-1} G_t^{(n)},$$

其中第 $n$ 步回报的权重为

$$w_n=(1-\lambda)\lambda^{n-1}.$$

可能会问为什么要这样进行权重分配，实际上该权重呈几何级数（衰减）.

权重需要构成一个概率分布，即权重之和为 $1$ :

$$\sum_{n=1}^{\infty}(1-\lambda)\lambda^{n-1}=(1-\lambda)\cdot \frac{1}{1-\lambda}=1.$$

几何分布的“无记忆性”： 几何分布是唯一具有无记忆性的离散分布.

[!note]- 几何分布
$X\sim G(p)\Leftrightarrow p_k=P(X=k)=p(1-p)^{k-1},k=1,2,\ldots.\quad 0<p<1.$

Thm. 若 $X\sim G(p)$，则对任意正整数 $m,n$，有

$$P(X>m+n\mid X>m)=P(X>n).$$

从直观上理解 $\lambda$ - 回报的构造过程：站在时刻 $t$，有两种选择：

以概率 $(1-\lambda)$ 停下，使用 1 步回报 $G_t^{(1)}$

以概率 $\lambda$ 继续走，在时刻 $t+1$，面临相同的选择这就产生了一个递归结构

$$G_t^{\lambda}=(1-\lambda)G_t^{(1)}+\lambda[(1-\lambda)G_t^{(2)}+\lambda[(1-\lambda)G_t^{(3)}+\cdots]].$$

最终展开后即得

$$G_t^{\lambda}=(1-\lambda)\sum_{n=1}^{\infty}\lambda^{n-1}G_t^{(n)}.$$

从前向视角 $\lambda$-回报到后向视角资格迹

在终止型任务中

$$G_t^{\lambda}=(1-\lambda)\sum_{n=1}^{T-t-1} \lambda^{n-1}G_t^{(n)}+\lambda^{T-t-1}G_t,$$

其中

$$G_t^{(n)} = R_{t+1} + \gamma R_{t+2} + \dots + \gamma^{n-1} R_{t+n} + \gamma^n V(S_{t+n}).$$

TD误差

$$\delta_k=R_{k+1}+\gamma V(S_{k+1})-V(S_k).$$

考虑离线 $\text{TD}(\lambda)$，即整个 episode 期间不改变状态价值，只记录所有 TD 误差和资格迹，等 episode 结束后一次性完成更新，此时在整个 episode 中，有

$$V_0(s)=V_1(s)=\cdots=V_T(s).$$

最后统一更新

$$V(s)\leftarrow V(s)+\Delta(s),$$

则有式(1)

$$\begin{aligned}\sum_{k=t}^{T-1}(\lambda\gamma)^{k-t}\delta_k = & \delta_t+\lambda\gamma\delta_{t+1}+(\lambda\gamma)^2\delta_{t+2}+\cdots+(\lambda\gamma)^{T-t-1}\delta_{T-1} \ = & R_{t+1} +\gamma V(S_{t+1})-V(S_t) + \ & \lambda\gamma( R_{t+2} + \gamma V(S_{t+2})- V(S_{t+1})) + \ & (\lambda\gamma)^2 (R_{t+3}+\gamma V(S_{t+3})-V(S_{t+2})) + \ & \cdots + \ & (\lambda\gamma)^{T-t-1}(R_T+\gamma V(S_T)-V(S_{T-1})) \ = & R_{t+1}+\lambda\gamma R_{t+2}+(\lambda\gamma)^2 R_{t+3}+\cdots \ & -V(S_t) + \ & (1-\lambda)\gamma V(S_{t+1}) + \ & (1-\lambda)\lambda\gamma^2 V(S_{t+2}) + \ & (1-\lambda)\lambda^2\gamma^3 V(S_{t+3}) + \ & \cdots + \ & (1-\lambda)\lambda^{T-t-2}\gamma^{T-t-1}V(S_{T-1}) + \ & \lambda^{T-t-1}\gamma^{T-t}V(S_T). \end{aligned}$$

终止状态 $V(S_T)=0$.

另一方面，

$$\begin{aligned} G_t^{(1)} & =R_{t+1}+\gamma V(S_{t+1}) \G_t^{(2)} & =R_{t+1}+\gamma R_{t+2}+\gamma^2 V(S_{t+2}) \G_t^{(3)} & =R_{t+1}+\gamma R_{t+2}+\gamma^2 R_{t+3}+\gamma^3 V(S_{t+3}) \& \cdots \G_t^{(T-t-1)} & =R_{t+1}+\gamma R_{t+2}+\cdots+\gamma^{T-t-2}R_{T-1}+\gamma^{T-t-1}V(S_{T-1})\G_t & =R_{t+1}+\gamma R_{t+2}+\cdots+ \gamma^{T-t-2}R_{T-1}+\gamma^{T-t-1}R_{T}.\end{aligned}$$

有式(2)

$$\begin{aligned} G_t^{\lambda}= & (1-\lambda)\sum_{n=1}^{T-t-1} \lambda^{n-1}G_t^{(n)}+\lambda^{T-t-1}G_t \ = & (1-\lambda)(1+\lambda+\cdots+\lambda^{T-t-2})R_{t+1}+\lambda^{T-t-1}R_{t+1} + \ & (1-\lambda)(\lambda+\lambda^2+\cdots+ \lambda^{T-t-2})\gamma R_{t+2} +\lambda^{T-t-1}R_{t+2} + \ & \cdots + \ & (1-\lambda)\gamma V(S_{t+1})+ \ & (1-\lambda)\lambda\gamma^2 V(S_{t+2}) + \ & \cdots + \ & (1-\lambda)\lambda^{T-t-2}\gamma^{T-t-1} V(S_{T-1}) \ = & R_{t+1}+\lambda\gamma R_{t+2}+(\lambda\gamma)^2 R_{t+3}+\cdots \ & (1-\lambda)\gamma V(S_{t+1})+ \ & (1-\lambda)\lambda\gamma^2 V(S_{t+2}) + \ & \cdots + \ & (1-\lambda)\lambda^{T-t-2}\gamma^{T-t-1} V(S_{T-1}). \end{aligned}$$

比较 $(1)$ 和 $(2)$ 得到

$$G_t^{\lambda}-V(S_t)=\sum_{k=t}^{T-1}(\lambda\gamma)^{k-t}\delta_k.$$

这意味着对 $V(S_t)$ 的更新可以表示为所有TD误差的加权和：

$$\Delta V(S_t)=\alpha\sum_{k=t}^{T-1}(\lambda\gamma)^{k-t}\delta_k.$$

在后向视角中，每产生一个 $\delta_k$，立即乘系数 $(\lambda\gamma)^{k-t}$ 传播给以前访问的状态，所有 TD 误差传播完成后，状态 $S_t$ 得到的累计更新就是$\alpha(G_t^{\lambda}-V(S_t))$.因此前向视角与后向视角两者在本质是统一的.

6. 资格迹与控制：Sarsa(λ)

价值估计的资格迹很自然地能推广到动作价值函数的控制问题.将资格迹从状态扩展为状态-动作对，我们就得到了 $\text{Sarsa}(\lambda)$.

6.1 前向 Sarsa(λ)方法

在 Sarsa($\lambda$)前向视角中，通过对每个回报赋予权重 $(1-\lambda)\lambda^{n-1}$ 来平均多个不同的 $Q$-回报进行更新，其中 $n$ 步 Sarsa 的 $Q$-回报为

$$ Q_t^{(n)}=R_{t+1}+\gamma R^{t+1}+\cdots +\gamma^{n-1}R_{t+n}+\gamma^n Q(S_{t+n},A_{t+n}), $$

则得到 $\lambda$-回报 $Q_t^{\lambda}$：

$$ Q_t^{\lambda}=(1-\lambda)\sum_{n=1}^{\infty}\lambda^{n-1}Q_t^{(n)}. $$

结合 Sarsa 的更新公式，得到前向视角 Sarsa($\lambda$)的更新公式为

$$ Q(S_t,A_t)\leftarrow Q(S_t,A_t)+\alpha (Q_t^{\lambda}-Q(S_t,A_t)). $$

6.2 后向 Sarsa(λ)方法

在 Sarsa($\lambda$)后向视角中，通过引入资格迹，将当前行为值函数误差按权重进行分配更新，每执行一个动作，我们更新资格迹 $E_t(s,a)$：

$$ E_t(s,a) = \begin{cases} \gamma \lambda E_{t-1}(s,a) + 1 & \text{如果 } (s,a) = (S_t, A_t), \text{（累积迹情况）} \ \gamma \lambda E_{t-1}(s,a) & \text{其他}, \end{cases} $$

其中 $E_0(s,a)=0$.TD 误差为：

$$ \delta_t = R_{t+1} + \gamma Q_t(S_{t+1}, A_{t+1}) - Q_t(S_t, A_t). $$

然后更新所有状态-动作对：

$$ Q_{t+1}(s,a) = Q_t(s,a) + \alpha \delta_t E_t(s,a),\ \forall s, a. $$

$\text{Sarsa}(\lambda)$ 算法伪代码：

后向 Sarsa(λ) 算法

输入：环境 E，状态空间 S，动作空间 A，折扣回报 γ，初始化行为值函数 Q(s,a) = 0,
	从 Q 导出的初始ε-greedy策略 π_0.

For k = 0, 1, ..., m do (针对每一条轨迹)
    初始化所有状态行为对的资格迹：E(s,a) = 0
    初始化状态 s 和行为 a，得到第一个状态行为对 (s, a)
    
    For t = 0, 1, 2, 3, ... do (针对轨迹中的每一步)
        r, s' ← 在 E 中执行动作 a 产生的回报和转移的状态；
        基于 s'，通过 ε-greedy 策略采取行为 a'，得到第二个状态行为对 (s', a')
        
        δ ← r + γ Q(s', a') − Q(s, a)  // TD 误差
        
        E(s, a) ← E(s, a) + 1          //更新当前状态行为对的资格迹
        
        对于所有的状态行为对 (s, a)：
            Q(s, a) ← Q(s, a) + α δ E(s, a)
            E(s, a) ← γ λ E(s, a)
        
        s ← s', a ← a'
        
        end for   // s 是一个终止状态
    end for

∀ s ∈ S：π*(s) = argmax_{a∈A} Q(s, a)

输出：最优策略 π*

7. 资格迹与控制：Q(λ)

常规的 Q-Learning 的更新目标为 1 步回报，即

$$ Q(S_t,A_t)\leftarrow Q(S_t,A_t)+\alpha (Q_t-Q(S_t,A_t)), $$

其中

$$ Q_t=R_{t+1}+\gamma \max_{a'}Q_t(S_{t+1},a'). $$

Q-Learning 估计的 $\pi^*$ 是 greedy 策略，在计算 TD 目标 $Q_t$ 时，对应的是 greedy 策略 $\pi$ 生成的轨迹.由于 O-Learning 是 off-policy，行为策略 $\mu$ ($\epsilon$-greedy) 与目标策略 $\pi$ (greedy)不同，即采样生成的真实轨迹与 $\pi$ 生成的可能不一致，因此在计算 $n$ 步回报时，根据采样真实轨迹不一定可以得到 $n$ 步对应的 TD 目标，由此在实际操作中，资格迹不能像 Sarsa($\lambda$)那样传播到整个 episode，而需要在某些时候截断.

为描述行为策略与目标策略对应轨迹的不同，并确定当前时间步选择的行为的性质，我们给出贪婪行为和探索行为的定义.

Def. 在当前状态 $s$ 下，若选择的行为 $a$ 满足

$$Q(s,a)=\max_{a'} Q(s,a')$$

则称该行为是贪婪行为，反之则为探索行为.

[!note]- 例 3：多步回报的限制考虑轨迹

$$s_0 \xrightarrow{a_0} R_1,s_1 \xrightarrow{a_1}R_2, s_2 \xrightarrow{a_2}R_3, s_3.$$

在常规 Q-Learning 的 1 步回报中，更新状态行为对 $(s_0,a_0)$ 的 $Q$ 值，所使用的是 $\max_{a'}Q(s_1,a')$，而不是实际执行的 $a_1$.并且由于只看到下一步，即使真实轨迹没有采取 greedy，我们仍然会认为从 $s_1$ 开始以后是 greedy 策略生成的轨迹，即无论 $a_1$ 是贪婪行为还是探索行为，不影响 $Q(s_0,a_0)$ 的更新；

若考虑多步回报，如 3 步回报，且 $a_1$ 为贪婪行为，$a_2$ 为探索行为，则 TD 目标 $Q^{(3)}$为

$$Q^{(3)}=R_{1}+\gamma R_{2}+\gamma^2 R_{3}+\gamma^3 \max_a Q(s_{3},a).$$

从 $a_2$ 开始，后面的轨迹不是 greedy 策略产生的，对应经验奖励 $R_3\ldots$ 不能再代表 $Q^*$，因此不能使用 3 步回报作为 TD 目标，进而更新 $Q(s_0,a_0)$ ^eg3

7.1 前向 Watkins's Q(λ) 方法

将 Q-Learning 的更新目标变为多步.假设正在求解贪心策略在状态行为对 $(s_t,a_t)$ 的行为值函数，前两个时间步选择的行为是贪婪行为，但第三个时间步选择的行为是探索行为.

$$ s_t \xrightarrow[\text{greedy}]{a_t} s_{t+1} \xrightarrow[\text{greedy}]{a_{t+1}} s_{t+2} \xrightarrow[\text{explore}]{a_{t+2}} s_{t+3} $$

对于 $(s_t,a_t)$，可以利用哪些回报？从例 3 中，我们可以得到，1 步回报和 2 步回报可以利用.3 步回报中，在 $s_{t+2}\xrightarrow{a_{t+2}} R_{t+3},s_{t+3}$ 中，$a_{t+2}$ 为探索行为，由于后续轨迹不是 greedy 策略产生，而是 $\epsilon$-greedy，因此 3 步回报不能使用.

1 步回报

$$ R_{t+1}+\gamma \max_a Q(s_{t+1},a). $$

2 步回报

$$ R_{t+1}+\gamma R_{t+2}+\gamma^2\max_a Q(s_{t+2},a). $$

3 步回报

$$ R_{t+1}+\gamma R_{t+2}+\gamma^2 R_{t+3}+\gamma^3 \max_a Q(s_{t+3},a). $$

结合上述对回报的利用， Watkins's $\text{Q}(\lambda)$ 使用的有效轨迹长度，最长就到第二个时间步，从第三个时间步往后的序列不再理会，即 Watkins's $\text{Q}(\lambda)$ 使用的有效轨迹长度最远到达第一个探索行为对应的时间步长.因此，Watkins's $\text{Q}(\lambda)$ 的有效轨迹长的不是整个轨迹从开始到结束，它只考虑最近的探索行为，一旦探索行为发生，则轨迹结束.

对状态行为对 $(s_t,a_t)$，第一个探索行为是 $a_{t+n}$，轨迹以 $s_{t+n}$ 为最后一个状态，则最长的 $n$ 步 Q-回报为

$$ Q_t^{(n)}=R_{t+1}+\gamma R_{t+2}+\cdots +\gamma^{n-1}R_{t+n}+\gamma^n \max_{a}Q(s_{t+n},a). $$

对 Q-回报加权求和得到 Q 的 λ-回报 $Q_t^\lambda$：

$$ Q_t^{\lambda}=(1-\lambda)\sum_{n=1}^\infty \lambda^{n-1}Q_t^{(n)}. $$

Watkins's $\text{Q}(\lambda)$ 更新公式为

$$ Q(s_t,a_t)\leftarrow Q(s_t,a_t)+\alpha(Q_t^\lambda - Q(s_t,a_t)). $$

7.2 后向 Watkins's Q(λ) 方法

对每个状态行为对 $(s,a)$，我们更新资格迹 $E_t(s,a)$：

$$ E_t(s,a) = I_{sS_t}\cdot I_{aA_t}+ \begin{cases} \gamma \lambda E_{t-1}(s,a) & \text{如果 } Q_{t-1}(S_t,A_t) = \max_{a'} Q_{t-1}(S_t, a'), \ 0 & \text{其他}, \end{cases} $$

其中

$$ I_{sS_t}=\begin{cases}1,\ s=S_t \ 0,\ s\neq S_t\end{cases},\quad I_{aA_t}=\begin{cases}1,\ a=A_t \ 0,\ a\neq A_t\end{cases} $$

即若当前选择行为 $a_t$ 是贪婪行为，则资格迹乘系数 $\gamma\lambda$，否则资格迹截断为 0；其次，对于当前正在访问的 $(s_t,a_t)$，其资格迹单独加 1.

$Q(s,a)$ 的更新公式为

$$ Q_{t+1}(s,a)= Q_t(s,a)+\alpha\delta_t E_t(s,a),\ \forall s,a, $$

其中

$$ \delta_t = R_{t+1}+\gamma \max_{a'} Q_t(s_{t+1},a')-Q_t(s_t,a_t). $$

后向 Watkins’s $\text{Q}(\lambda)$ 算法伪代码：

后向 Watkins’s Q(λ) 算法

输入：环境 E，状态空间 S，动作空间 A，折扣回报 γ，初始化行为值函数 Q(s,a) = 0,
	从 Q 导出的初始ε-greedy策略 π_0.

For k = 0, 1, ..., m do (针对每一条轨迹)
    初始化所有状态行为对的资格迹：E(s,a) = 0
    初始化状态 s 和行为 a，得到第一个状态行为对 (s, a)
    
    For t = 0, 1, 2, 3, ... do (针对轨迹中的每一步)
        r, s' ← 在 E 中执行动作 a 产生的回报和转移的状态；
        基于 s'，通过 ε-greedy 策略采取行为 a'，得到第二个状态行为对 (s', a')
        
        a* ← argmax_{b∈A} Q(s', b)    // 贪心动作（用于资格迹衰减判断）
        δ ← r + γ Q(s', a*) − Q(s, a)  // TD误差 （使用贪心动作 a* 的Q值）
        
        E(s, a) ← E(s, a) + 1          // 更新当前状态行为对的资格迹
        
        对于所有的状态行为对 (s, a)：
            Q(s, a) ← Q(s, a) + α δ E(s, a)
            
            // Watkins’s 修正：仅当 a' = a*（即实际采取的动作是贪心动作）时才衰减资格迹；
            // 否则，将非贪心路径上的资格迹截断为0
            如果 a' = a*，则有 E(s, a) ← γ λ E(s, a)
            否则 E(s, a) ← 0
            
        s ← s', a ← a'
        
        end for   // s 是一个终止状态
    end for

∀ s ∈ S：π*(s) = argmax_{a∈A} Q(s, a)

输出：最优策略 π*

事实上，当存在多个贪婪行为时，即

$$ #{a'\mid Q(s',a')=\max_{b}Q(s',b) }\triangleq # A^*(s')>1, $$

若上述算法中 $a'\neq a^\in A^(s')$，则会出现本来仍然符合贪婪策略的轨迹被错误截断.因此上述的贪心动作可更改为贪心动作集合 $A^(s')$，以及资格迹更新条件变为 $a'\in A^(s')$.

[!note]- 例 4 资格迹更新状态序列

$$s_t \xrightarrow[\text{greedy}]{a_t} s_{t+1} \xrightarrow[\text{greedy}]{a_{t+1}} s_{t+2} \xrightarrow[\text{explore}]{a_{t+2}} s_{t+3}.$$

在 $(s_t,a_t)$ 处，$E(s_t,a_t)=1$，$a_t$ 是贪婪行为，则资格迹继续衰减并累计

$$\begin{aligned} & E(s_t,a_t)=\gamma\lambda, \ &E(s_{t+1},a_{t+1})=1. \end{aligned}$$

再执行下一步 $(s_{t+2},a_{t+2})$ ，此时得到

$$\begin{aligned} & E(s_t,a_t)=(\gamma\lambda)^2, \ & E(s_{t+1},a_{t+1})=\gamma\lambda, \ & E(s_{t+2},a_{t+2})=1. \end{aligned}$$

在探索动作发生之前，各状态行为对的资格迹均保留，且当前 TD 误差能够传播给之前访问过的状态动作对.

而在 $a_{t+2}$ 不是贪婪动作，表明此后轨迹偏离目标策略，后续经验不能用于估计greedy策略的价值，因此，在计算完当前一步更新后，资格迹立即清理：

$$E(s,a)=0,\ \forall s,a$$

原来的资格迹 $E(s_t,a_t),E(s_{t+1},a_{t+1}),E(s_{t+2},a_{t+2})$ 均变为 $0$.

若不清零，则随后计算得到的 TD 误差 $\delta_{t+3}$ 仍会更新 $(s_t,a_t)$, $(s_{t+1},a_{t+1})$ 和 $(s_{t+2},a_{t+2})$ 对应值，即探索行为后的经验影响了原本目标贪婪策略，因此此时需将资格迹截断清零.

[!note]- 例 5：悬崖行走任务经典的悬崖行走网格中，智能体从起点到终点，途中某些格是悬崖，掉下去会获得 -100 奖励并回到起点.用 Sarsa(0) 学习，智能体学到的安全路径会远离悬崖（因为探索时有概率掉下悬崖，一步更新过于谨慎）.若使用 $\text{Sarsa}(\lambda)$ 并取较大的 λ，掉下悬崖的大负奖励会被迹传播到更早的状态-动作对，那些导致接近悬崖路径的动作会受到更强的惩罚，智能体可能更快地学会避开危险区域.同时，正奖励的传播也更快，使得成功路径的 Q 值提升更迅速.实验通常显示，在 λ≈0.7～0.9 时学习速度明显快于 λ=0.

8. 总结

本节脉络：

动机：一步更新的信息传播瓶颈与蒙特卡洛的高方差，促使我们寻找多步信息的在线融合方式.
前向 λ 回报：对 n 步回报的指数加权平均，给予我们偏差-方差可调的理想更新目标.
后向资格迹：通过“迹”来记录每个状态的访问新近度与频率，将每一步的 TD 误差按迹分配给历史状态，从而在在线更新中等价于前向 λ 回报.
$\text{Sarsa}(\lambda)$ 与 $\text{Q}(\lambda)$：将迹扩展到动作值函数，实现多步同策略控制，显著加速学习.

教材参考

邹伟 - 强化学习 - 清华大学出版社.

Richard S. Sutton - Reinforcement Learning: An Introduction.

3 基于动态规划的强化学习方法

Tue, 16 Jun 2026 00:00:00 GMT

我们的目标是：不仅知道动态规划在强化学习里怎么用，更要理解 为什么能用，以及 怎样从基本思想一步步生长出策略迭代、值迭代和截断策略迭代这些算法 。

1. 引言：强化学习的骨架——马尔可夫决策过程

在聊动态规划之前，我们必须先快速建好一个舞台——马尔可夫决策过程 (MDP)。强化学习要解决的问题，几乎都可以形式化为 MDP。

想象一个网格世界，一个智能体要从左上角走到右下角，避开陷阱，捡到宝石。这个场景天然包含几个要素：

状态 (State)：智能体在哪个格子，比如坐标 (1,1) 到 (4,4)。
动作 (Action)：向上、向下、向左、向右。
奖励 (Reward)：踩到宝石 +1，掉进陷阱 -1，其他每走一步 -0.01（鼓励尽快到达）。
状态转移概率 $P(s'|s,a)$：给定当前状态 $s$ 和动作 $a$，到达下一个状态 $s'$ 的概率。比如机器人可能因地面湿滑，有 20%概率滑向别的方向。
折扣因子 $\gamma \in [0,1]$：未来奖励的折扣程度。

MDP 的核心假设——马尔可夫性：下一状态只依赖于当前状态和动作，与历史无关。这个假设让我们能递归地定义“长期收益”。

给定一个策略 $\pi(a|s)$（在状态 $s$ 选各动作的概率），从状态 $s$ 出发的期望回报就是状态价值函数：

$$ v_\pi(s) = \mathbb{E}\pi\left[ \sum{t=0}^\infty \gamma^t R_{t+1} \mid S_0 = s \right] $$

通过全概率展开，我们得到著名的贝尔曼期望方程：

$$ v_\pi(s) = \sum_a \pi(a|s) \sum_{s'} P(s'|s,a) \left[ R(s,a,s') + \gamma v_\pi(s') \right] $$

也就是说，一个状态的价值，等于即时奖励加上下一状态价值的期望折现值。这个方程看上去简单，但它揭示了价值函数的自洽性——我们后面所有动态规划算法，本质上都是在不断强制这种自洽性成立。

例子 1（4×4 网格世界）：假设智能体策略是“均匀随机行走”，$\gamma=0.9$。计算状态(4,4)是终点，$v(4,4)=0$。那么状态(4,3)的值，就等于向右走的期望回报：$-0.01 + 0.9 \times 1 \times 0 = -0.01$（若确定转移）。但实际上随机策略有概率走到别处，所以值会略有不同。通过贝尔曼方程，我们可以从终点倒推每个格子的值。

现在的问题是：如果环境模型（$P$ 和 $R$）完全已知，我们要么找出最优策略，要么评估某个策略的值，该怎么做？这便引入了动态规划。

2. 动态规划引入：贝尔曼方程的另一种视角

2.1 什么是动态规划

“动态规划 (Dynamic Programming, DP)”这个名词里的“规划”，不是编程，而是规划 (Planning)，即在已知环境模型的前提下，进行推理和优化。Bellman 在 1950 年代提出 DP 时，核心思想就两条：

最优子结构：一个问题的最优解包含其子问题的最优解。
重叠子问题：递归求解时，同样的子问题被反复计算。

在 MDP 中，这两个性质体现得淋漓尽致：价值函数定义本身就是递归的；同一个状态的价值在评估多个策略时会反复用到。

2.2 强化学习为什么能使用动态规划？

回答这个问题，只需看 DP 的两个前提条件在我们这里是否满足：

最优子结构存在吗？ 是的。贝尔曼最优方程给出了最优价值函数的递归定义： $$ v_(s) = \max_a \sum_{s'} P(s'|s,a) \left[ R(s,a,s') + \gamma v_(s') \right] $$ 最优策略的长期收益最大值，等于当前最佳动作带来的即时收益加上后续最优收益。
重叠子问题存在吗？ 是的。整个 MDP 的状态空间是有限的，价值函数对每个状态都需要求解，而相邻状态的值相互依赖，天然是一个包含大量重叠的方程组。

但还有一个更实际的约束：MDP 模型完全已知。在“规划”问题里，$P$ 和 $R$ 都是已知的，这允许我们直接使用 DP 进行迭代求解。强化学习中的很多问题（如围棋棋盘、机器人控制）模型未知或难以精确建模，那时就需要模型自由的方法。但理解 DP 是理解一切强化学习的起点。

小结：如果 MDP 已知且状态-动作空间不太大，DP 就能大展拳脚。

3. 策略迭代：先评后改，循环往复

策略迭代是 DP 最直接的体现，包含两步：策略评估 和 策略改进。

3.1 策略评估（Policy Evaluation）

给定一个策略 $\pi$，我们想计算它的价值函数 $v_\pi$。贝尔曼期望方程给出了一个方程组，对每个状态 $s$： $$ v_\pi(s) = \sum_a \pi(a|s) \sum_{s'} P(s'|s,a) [R(s,a,s') + \gamma v_\pi(s')] $$ 我们可以用迭代法求解：初始化 $v_0(s)$ 任意（比如全 0），然后用上面的公式作为更新规则，不断用右侧算出的新值替换旧值：

$$ v_{k+1}(s) \leftarrow \sum_a \pi(a|s) \sum_{s'} P(s'|s,a) [R + \gamma v_k(s')] $$

这被称为迭代策略评估。理论上，当 $k \to \infty$，$v_k$ 会收敛到 $v_\pi$。

3.2 策略改进（Policy Improvement）

有了 $v_\pi$，我们可以问：在当前状态 $s$，是否有一个动作 $a$ 比遵循 $\pi$ 带来更高收益？只需计算动作价值函数： $$ q_\pi(s,a) = \sum_{s'} P(s'|s,a)[R + \gamma v_\pi(s')] $$ 如果存在 $a$ 使得 $q_\pi(s,a) > v_\pi(s)$，那么把 $s$ 的策略改为始终选 $a$，就得到了一个更好的策略。正式地，产生新策略 $\pi'$： $$ \pi'(s) = \arg\max_a q_\pi(s,a) $$ 这就是策略改进定理，保证 $\pi'$ 严格优于 $\pi$（除非 $\pi$ 已是最优）。

3.3 策略迭代算法

将评估和改进结合：

初始化 $v(s)$ 和 $\pi(s)$ 任意。
策略评估：循环更新 $v(s)$ 直到收敛（或变化足够小）。
策略改进：对每个状态，更新策略 $\pi(s) \leftarrow \arg\max_a q_\pi(s,a)$。
若策略不再变化，停止；否则回到步骤 2。

例子 2（网格世界策略迭代）
还是 4×4 网格，终点(4,4)，陷阱(2,2)，$\gamma=0.9$。初始策略：全向上。

第一轮策略评估：计算出向上策略的价值。发现(1,1)的价值很低，因为向上撞墙。(3,4)价值较高，因为向右可快速到终点。
策略改进：在(3,4)处，计算各动作的$q$值，发现向右的$q$值最大，策略改为向右；在(1,1)处，向下$q$值更大，策略改为向下。
重复评估-改进，最终得到最优策略：从任何格子出发都沿着最优路径走向(4,4)，避开(2,2)。

这个过程就像“自我反省”：先完整地把当前策略的后果想清楚（评估），再据此调整行动（改进）。

4. 值迭代：一步到位，省去漫长的评估

策略迭代每轮都要把 $v_\pi$ 算到收敛，这在大型问题中开销巨大。我们能否在一次迭代中同时做评估和改进？这就是值迭代。

回忆贝尔曼最优方程： $$ v_(s) = \max_a \sum_{s'} P(s'|s,a) [R + \gamma v_(s')] $$ 它本身就是一个不动点方程。我们可以直接从任意 $v_0$ 开始，反复应用最优备份： $$ v_{k+1}(s) = \max_a \sum_{s'} P(s'|s,a) [R + \gamma v_k(s')] $$ 这个更新规则不需要策略，直接在值函数上贪婪地取 max。它就是值迭代。

值迭代可以看作策略迭代的极限情况：在策略评估阶段，我们只做一次全扫描，然后就进行策略改进（即贪婪选择 max），但其实 max 操作已经内嵌了改进。更准确地说，值迭代是在 $v$ 上直接运行贝尔曼最优备份，直到收敛。收敛后，最优策略就是： $$ \pi_(s) = \arg\max_a \sum_{s'} P(s'|s,a)[R + \gamma v_(s')] $$

例子 3（最短路径问题）
考虑一个最短路径 MDP：状态为节点，每走一步奖励 $-1$，直到到达终点，$\gamma=1$（无折扣）。这是一个确定性环境。

初始 $v_0(s)=0$ 对所有非终点，终点值恒为 0。
第一轮值迭代：对每个节点，$v_1(s) = \max_a [-1 + v_0(s')] = -1$（因为 $v_0(s')=0$）。这样相邻终点的节点获得价值-1。
第二轮：这些节点的邻居再往外传，价值变成-2。不断向外扩散，最终每个节点的$v$值就是负的最短距离。这正是经典的 Bellman-Ford 算法思想。每一步，信息从终点向外传播一个距离单位。

例子 4（赌徒问题）
赌徒有资金 $s \in {1,2,\dots,99}$，目标是达到 100。每轮可下注 $a \in {1,\dots,\min(s,100-s)}$，以概率 $p=0.4$ 赢（资金+$a$），否则输（资金-$a$）。奖励在达到 100 时为+1，其他为 0。$\gamma=1$。

状态空间 101 个（含 0 和 100 吸收态）。
值迭代：初始化 $v_0(s)=0$，终点 $v(100)=1, v(0)=0$。
迭代过程：$v_{k+1}(s) = \max_a [0.4 v_k(s+a) + 0.6 v_k(s-a)]$。随着 $k$ 增大，赢的概率信息从 100 传播回小资金状态。观察值函数的形状会是一个有趣的阶梯状，反映最优下注策略（通常倾向于大胆下注）。这个例子很好地展示了值迭代如何处理概率性 MDP。

值迭代的优势是简单，每轮只需 $O(|S|^2 |A|)$ 或类似复杂度的一次扫描。但它每次更新都取 max，容易在早期高估，不过收敛是有保证的。

5. 截断策略迭代：在两种极端之间自由游走

5.1 广义策略迭代（GPI）

策略迭代和值迭代其实是两个极端：一个是评估到收敛再改进，一个是评估一步就改进。实际上，任何评估与改进交替进行的过程，都称为广义策略迭代 (GPI)。评估让价值与当前策略一致，改进让策略相对当前价值变得贪婪；两者相互驱动，直到同时达到稳定，即最优。

5.2 截断策略迭代

截断策略迭代（Truncated Policy Iteration）就是在策略评估时，不等到收敛，只做固定次数的迭代（如 $m$ 次），然后停止评估并改进策略。当 $m=1$ 时，它退化为值迭代；当 $m=\infty$ 时，就是策略迭代。所以它是一个灵活的算法族。

为什么需要它？ 在大型状态空间中，策略迭代的完全评估太慢，值迭代的 max 更新又可能振荡、收敛也不总是最快。适当多评估几次（$m>1$）常能显著加速总收敛时间——用更少的全局扫描次数得到最优解。

例子 5（网格世界加速对比）
同一网格世界任务，比较三种方法达到收敛所需的扫描次数：

策略迭代：每次评估需约 200 次扫描（收敛门槛很小），但改进后策略跳变得大，总扫描次数可能中等。

值迭代：每次只做 1 次评估扫描，但需要上千次迭代才收敛。

截断策略迭代（$m=10$）：每次评估 10 次扫描，策略改进更快，总扫描次数可能远小于前两者。这直观体现了：少量额外的评估可以带来更“稳定”的价值估计，使策略改进更准确，避免值迭代中因贪婪造成的“短视震荡”。

算法伪代码：

初始化 v(s) 任意，π(s) 任意
循环：
    # 截断策略评估：对当前 π，进行 m 次更新
    重复 m 次：
        对每个状态 s：
            v(s) ← Σ_a π(a|s) Σ_{s'} P(s'|s,a)[R + γ v(s')]
    # 策略改进
    对每个状态 s：
        π_old(s) ← π(s)
        π(s) ← argmax_a Σ_{s'} P(s'|s,a)[R + γ v(s')]
    若 π 未改变，跳出循环
返回 π 和 v

这个框架揭示了强化学习方法的核心哲学：评估与改进的交替。这不仅是 DP，之后的蒙特卡洛、TD 学习等无非是把未知模型下的采样引入进来，但 GPi 结构永恒不变。

6. 总结与展望

我们今天从 MDP 出发，认识了状态价值函数和贝尔曼方程，这为动态规划提供了理论上的“最优子结构”和“重叠子问题”性质。当模型已知时，DP 便成为求解最优策略的利器。

我们依次探讨了：

策略迭代：完整评估当前策略，然后贪婪改进，循环往复。
值迭代：将评估与改进融合在一步贝尔曼最优备份中，省去完整评估。
截断策略迭代：在评估过程中只做有限次迭代，是前两者的折中，常常在实践中收敛最快。

每一个算法都在回答同一个核心问题：如何利用递归结构，高效地计算出每个状态的长期价值，并从中提炼出最优行为。

下一步的伏笔：

当模型 $P, R$ 未知时，DP 无法直接应用，我们需要从与环境交互的数据中学习——这导向蒙特卡洛方法和时序差分学习 (TD)。
当状态空间巨大或连续时，表格型 DP 不适用，我们需要引入函数逼近（如神经网络）——这导向深度强化学习。

但无论走多远，DP 中的贝尔曼方程、价值函数自洽性、以及广义策略迭代的结构，始终是支撑整个强化学习大厦的根基。

讨论与问答环节（开放）

欢迎大家提出问题。如果时间有余，我们可以围绕以下问题进行讨论：

策略迭代中，策略评估到底需要多精确？不精确的评估会不会导致改进失效？
值迭代和策略迭代在收敛速度上的理论保证是什么？
截断策略迭代中 $m$ 如何选择？有没有自适应的方法？

Git 操作命令

Wed, 21 Jan 2026 00:00:00 GMT

操作

一、仓库初始化与克隆

1. 初始化新仓库

git init                        # 初始化当前目录为 Git 仓库
git init <directory>            # 在指定目录初始化
git init --bare                 # 创建裸仓库（用于远程仓库）

2. 克隆现有仓库

git clone <url>                 # 克隆仓库到当前目录
git clone <url> <folder>        # 克隆到指定文件夹
git clone --depth 1 <url>       # 浅克隆（只获取最新提交）
git clone --branch <branch> <url>  # 克隆指定分支

二、基本工作流操作

1. 检查状态

git status                      # 查看工作区和暂存区状态
git status -s                   # 简洁模式
git status --short              # 同上

2. 添加到暂存区

git add <file>                  # 添加指定文件
git add .                       # 添加所有新文件和修改的文件
git add -A                      # 添加所有文件（包括删除）
git add -u                      # 只添加已跟踪文件的修改和删除
git add *.js                    # 添加匹配模式的文件
git add --patch                 # 交互式添加部分修改

3. 提交更改

git commit -m "message"         # 提交并添加描述
git commit -am "message"        # 添加所有修改并提交（跳过 git add）
git commit --amend              # 修改最后一次提交
git commit --amend -m "新消息"  # 修改最后一次提交信息
git commit --allow-empty        # 创建空提交

4. 查看历史

git log                         # 查看提交历史
git log --oneline               # 简洁的单行显示
git log --graph                 # 图形化显示分支合并
git log --stat                  # 显示文件修改统计
git log -p                      # 显示具体修改内容
git log -n 5                    # 只显示最近5次提交
git log --since="2023-01-01"    # 按时间筛选
git log --author="name"         # 按作者筛选
git log --grep="关键字"         # 按提交信息筛选
git log <file>                  # 查看文件的提交历史

三、分支管理

1. 查看分支

git branch                      # 查看本地分支
git branch -a                   # 查看所有分支（包括远程）
git branch -r                   # 查看远程分支
git branch -v                   # 查看分支及最新提交
git branch -vv                  # 查看分支及跟踪关系

2. 创建分支

git branch <name>               # 创建新分支
git branch <name> <commit>      # 从指定提交创建分支
git checkout -b <name>          # 创建并切换到新分支
git switch -c <name>            # Git 2.23+ 创建并切换

3. 切换分支

git checkout <branch>           # 切换到分支
git switch <branch>             # Git 2.23+ 切换分支
git checkout -                  # 切换到上一个分支

4. 合并分支

git merge <branch>              # 合并指定分支到当前分支
git merge --no-ff <branch>      # 禁用快速合并（保留合并历史）
git merge --squash <branch>     # 压缩合并（合并为一次提交）
git merge --abort               # 终止合并（解决冲突时）

5. 删除分支

git branch -d <branch>          # 删除已合并的分支
git branch -D <branch>          # 强制删除分支
git push origin --delete <branch>  # 删除远程分支

四、远程仓库操作

1. 管理远程仓库

git remote                      # 查看远程仓库
git remote -v                   # 查看远程仓库及 URL
git remote add <name> <url>     # 添加远程仓库
git remote remove <name>        # 删除远程仓库
git remote rename <old> <new>   # 重命名远程仓库
git remote set-url <name> <url> # 修改远程仓库 URL

2. 拉取和推送

git fetch                       # 从远程获取最新信息（不合并）
git fetch <remote>              # 从指定远程获取
git fetch --prune               # 获取并清理已删除的远程分支

git pull                        # 获取并合并到当前分支
git pull <remote> <branch>      # 从指定远程分支拉取
git pull --rebase               # 拉取并使用 rebase 合并

git push                        # 推送到远程仓库
git push <remote> <branch>      # 推送到指定远程分支
git push -u <remote> <branch>   # 推送并设置 upstream
git push --force                # 强制推送（慎用）
git push --force-with-lease     # 安全强制推送

五、撤销与回退

1. 撤销工作区修改

git checkout -- <file>          # 撤销工作区的修改
git restore <file>              # Git 2.23+ 恢复文件

2. 撤销暂存区修改

git reset HEAD <file>           # 将文件移出暂存区
git restore --staged <file>     # Git 2.23+ 取消暂存

3. 回退提交

git reset --soft HEAD~1         # 回退提交但保留修改在暂存区
git reset --mixed HEAD~1        # 回退提交且保留修改在工作区（默认）
git reset --hard HEAD~1         # 彻底回退（删除修改）

git revert <commit>             # 创建新的提交来撤销指定提交
git revert HEAD                 # 撤销最后一次提交
git revert --no-commit <commit> # 撤销但不自动提交

六、暂存与储藏

1. 储藏（Stash）

git stash                       # 储藏当前修改
git stash save "message"        # 储藏并添加描述
git stash -u                    # 储藏包括未跟踪的文件
git stash -a                    # 储藏所有文件

git stash list                  # 查看储藏列表
git stash show stash@{0}        # 查看指定储藏的修改
git stash show -p stash@{0}     # 查看具体修改内容

git stash pop                   # 恢复最新储藏并删除
git stash pop stash@{0}         # 恢复指定储藏
git stash apply                 # 恢复最新储藏但不删除
git stash apply stash@{0}       # 恢复指定储藏但不删除

git stash drop stash@{0}        # 删除指定储藏
git stash clear                 # 删除所有储藏

git stash branch <name>         # 从储藏创建新分支

七、标签管理

1. 创建标签

git tag <tagname>               # 创建轻量标签
git tag -a <tagname> -m "msg"   # 创建附注标签
git tag <tagname> <commit>      # 给指定提交打标签

2. 查看标签

git tag                         # 查看所有标签
git tag -l "v1.*"               # 按模式查找标签
git show <tagname>              # 查看标签详细信息

3. 操作标签

git push origin <tagname>       # 推送标签到远程
git push origin --tags          # 推送所有标签
git tag -d <tagname>            # 删除本地标签
git push origin --delete <tagname>  # 删除远程标签

八、比较与差异

1. 查看差异

git diff                        # 工作区 vs 暂存区
git diff --staged               # 暂存区 vs 最新提交
git diff HEAD                   # 工作区 vs 最新提交
git diff <commit>               # 工作区 vs 指定提交
git diff <commit1> <commit2>    # 两个提交间的差异
git diff --name-only            # 只显示文件名
git diff --stat                 # 显示统计信息

2. 比较分支

git diff <branch1>..<branch2>   # 两个分支间的差异
git diff <branch1>...<branch2>  # 两个分支从共同祖先开始的差异

九、配置管理

1. 用户配置

git config --global user.name "Your Name"
git config --global user.email "email@example.com"
git config --global core.editor "vim"  # 设置默认编辑器

2. 别名配置

git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.st status
git config --global alias.lg "log --oneline --graph --all"

3. 查看配置

git config --list               # 查看所有配置
git config user.name            # 查看特定配置项
git config --global --list      # 查看全局配置
git config --local --list       # 查看本地仓库配置

十、高级操作

1. Rebase（变基）

git rebase <branch>             # 变基到指定分支
git rebase -i HEAD~5            # 交互式变基（最近5个提交）
git rebase --continue           # 继续变基（解决冲突后）
git rebase --abort              # 终止变基
git rebase --skip               # 跳过当前提交

2. Cherry-pick

git cherry-pick <commit>        # 应用指定提交
git cherry-pick <commit1> <commit2>  # 应用多个提交
git cherry-pick --abort         # 终止 cherry-pick

3. Bisect（二分查找）

git bisect start                # 开始二分查找
git bisect bad                  # 标记当前为坏提交
git bisect good <commit>        # 标记某个提交为好的
git bisect reset                # 结束二分查找

4. 子模块

git submodule add <url> <path>  # 添加子模块
git submodule init              # 初始化子模块
git submodule update            # 更新子模块
git submodule update --init --recursive  # 递归初始化和更新

十一、清理与维护

1. 清理文件

git clean -n                    # 显示将要清理的文件（预览）
git clean -f                    # 强制清理未跟踪的文件
git clean -fd                   # 清理未跟踪的文件和目录
git clean -x                    # 清理包括忽略的文件

2. 垃圾回收

git gc                          # 垃圾回收，优化仓库
git gc --aggressive             # 更激进的优化
git prune                       # 删除悬空对象

十二、工作流快速参考

日常开发流程

# 1. 开始新功能
git checkout main              # 切换到主分支
git pull origin main           # 更新到最新
git checkout -b feature/new    # 创建功能分支

# 2. 开发过程
git add .                      # 添加修改
git commit -m "添加新功能"      # 提交
git push origin feature/new    # 推送到远程

# 3. 完成功能
git checkout main              # 回到主分支
git pull origin main           # 更新主分支
git merge feature/new          # 合并功能分支
git push origin main           # 推送主分支
git branch -d feature/new      # 删除本地分支

紧急修复流程

# 1. 创建修复分支
git checkout main
git checkout -b hotfix/urgent

# 2. 修复并提交
git add .
git commit -m "紧急修复"
git push origin hotfix/urgent

# 3. 合并到多个分支
git checkout main
git merge hotfix/urgent
git push origin main

git checkout develop
git merge hotfix/urgent
git push origin develop

十三、实用技巧

1. 查看引用日志

git reflog                      # 查看所有操作记录
git reflog show <branch>        # 查看特定分支的操作记录

2. 查看文件历史

git blame <file>                # 逐行查看文件修改历史
git log -p <file>               # 查看文件的详细修改历史
git show <commit>:<file>        # 查看指定提交的文件内容

3. 重写历史

# 注意：这会改变提交历史，只在自己的分支使用
git rebase -i HEAD~10           # 交互式修改最近10个提交
git filter-branch               # 批量修改历史（慎用）

📊 命令速查表

| 类别 | 常用命令 | 用途 | |------|----------|------| | 初始化 | git init, git clone | 创建/获取仓库 | | 状态 | git status, git log | 查看状态和历史 | | 提交 | git add, git commit | 保存更改 | | 分支 | git branch, git checkout | 分支管理 | | 合并 | git merge, git rebase | 合并代码 | | 远程 | git remote, git push, git pull | 远程协作 | | 撤销 | git reset, git revert, git checkout -- | 撤销操作 | | 储藏 | git stash | 临时保存工作 | | 标签 | git tag | 版本标记 |

Git 清空历史

Fri, 02 Jan 2026 00:00:00 GMT

如何彻底清空 Git 提交历史并重新开始？

在长期维护的 Git 项目中，提交记录可能会变得杂乱无章，影响性能和可读性。本篇介绍四种方法彻底清空 Git 提交历史，包括删除 .git 目录、创建无历史分支、使用 git filter-repo 以及手动迁移代码。可以根据项目需求选择最合适的方式。

1. 删除 `.git` 目录并重新初始化（最干净的方法）

如果你想彻底清空所有 Git 记录并从头开始，最简单的方法就是直接删除 .git 目录并重新初始化仓库：

rm -rf .git  # 删除 Git 目录
git init     # 重新初始化 Git 仓库
git add .    # 添加所有文件
git commit -m "Initial commit"  # 创建新的提交

优点：

彻底清空所有提交记录。
简单直接。
适用于个人项目或小团队。

缺点：

需要重新设置 .gitignore 文件。
远程仓库关联会丢失，需要手动添加 git remote add origin <repo-url>。

2. 创建无历史的新分支 (`--orphan` 方法)

如果你希望清空提交历史但仍保留 .git 目录和远程仓库，可以使用 --orphan 创建一个新的无历史分支：

git checkout --orphan clean-main

然后添加所有文件并提交：

git add .
git commit -m "Initial commit"

删除旧的 main 分支，并将新分支重命名回 main：

git branch -D main  # 删除旧的 main 分支
git branch -m main  # 将 clean-main 重命名为 main

如果需要覆盖远程仓库（谨慎操作！）：

git push --force origin main

优点：

保留 .git 目录，不影响 Git 相关配置。
代码保留，但所有历史提交会被清空。

缺点：

远程仓库需要强制推送，可能影响团队成员。

3. 使用 `git filter-repo` 清理提交历史（适用于大项目）

如果你的项目非常大，历史提交太多，Git 官方推荐使用 git filter-repo（比 git filter-branch 更高效）：

git filter-repo --path . --force

然后强制推送到远程仓库：

git push --force --all

优点：

高效，适用于大仓库。
清理提交历史但保留 .git 目录。

缺点：

需要安装 git filter-repo。

如果未安装，可以使用以下命令安装（适用于 macOS）：

brew install git-filter-repo

4. 复制代码到新仓库（最彻底的方法）

如果你希望彻底摆脱所有历史记录，并创建一个全新的仓库，最干净的方法是手动复制代码：

创建一个新目录，然后复制你的代码（不包括 .git 目录）。

进入新目录，初始化 Git：

git init
git add .
git commit -m "Initial commit"

如果有远程仓库，重新添加它：

git remote add origin <repo-url>
git push -u origin main --force

优点：

绝对干净，没有任何历史遗留问题。
适合长期维护的大型项目。

缺点：

需要手动迁移远程仓库。
远程仓库的旧记录仍然可能存在（可选择删除并重新创建仓库）。

方法对比总结

|方法|适用情况|是否保留 .git|是否需要远程强制推送| |---|---|---|---| |删除 .git 重新初始化|彻底重置，最简单|❌ 否|✅ 需要| |创建无历史新分支|只想清空提交记录|✅ 是|✅ 需要| |git filter-repo 清理历史|处理大仓库，官方推荐|✅ 是|✅ 需要| |手动复制到新仓库|最干净，适合长期维护|❌ 否|✅ 需要|

如果你只是想让提交记录清零，同时保留远程仓库，方法 2（--orphan） 是比较推荐的。如果你完全不在乎历史，方法 1（删除 .git） 最直接。

1 强化学习概述

Thu, 01 Jan 2026 00:00:00 GMT

强化学习：(再励学习、评价学习)机器学习方法. 本质：解决决策问题，针对具体问题得到一最优策略，使获得奖励最大.

强化学习的背景

强化学习方法：起源于动物心理学相关原理，模仿人类和动物学习的试错机制；是一种通过与环境交互，学习状态到行为的映射关系，也即策略，表示在各个状态下，智能体采取的行为或行为概率.

强化学习初探

智能体与环境

强化学习方法包括智能体(学习者或玩家)和环境(与智能体交互的外部)两大对象.

强化学习原理： 离散时间序列 $t=0,1,2\ldots$ ，智能体在每一时间 $t$，从环境接收状态 $s_t$ ，通过行为 $a_t$ 继续与环境交互，而环境产生新的状态 $s_{t+1}$ ，并给出一立即回报 $r_{t+1}$ ，并不断交互下去，

区分智能体与环境：

方法一：智能体是存在于环境中，能够与环境进行交互，自主采取行动以完成任务的强化学习系统，系统之外为环境.

扫地机器人的电动机和机械结构及传感器硬件——环境；基于强化学习的路径规划算法——智能体；
AlphaGo算法本身——智能体；当前旗局和回报——外部环境；

方法二：外部环境是不能被智能体随意改变的东西. e.g.回报.

智能体主要组成

策略：映射 $\pi (a\mid s)$ :状态 $\mapsto$ 行为
值函数： $V_{\pi}(s),\ Q_{\pi}(s,a)$
模型： $P_s^a,\ R_s^a$

策略

决定智能体行为的机制，是状态到行为的映射，

$$ \pi(a\mid s)=P(A_t=a\mid S_t=s), $$

表示智能体在各个状态下各种可能的行为及概率. 2. 策略分类 * 确定性策略（ $\mu(s)=a$ ） * 随机性策略：根据状态输出每个动作的概率，输出值为概率分布 3. 策略仅和当前的状态有关, 与历史信息无关.

值函数

代表智能体在给定状态下的表现，或给定状态下某行为好坏程度，用未来的期望回报表示.
回报（收益 or 奖励）$G_t$：从 $t$ 时刻开始往后所有回报的有衰减的总和

$$ G_t=R_{t+1}+\gamma R_{t+2}+\ldots =\sum_{k=0}^\infty\gamma^k R_{t+1+k}, $$

折扣因子（衰减系数） $\gamma$：未来的回报在当前时刻价值比例. $\gamma$ 接近0：趋向于「近视」性评估；$\gamma$ 接近1：偏重考虑远期利益. 3. 值函数类别

状态值函数 $V_{\pi}(s)$：从状态 $s$ 开始，遵循当前策略 $\pi$ 所获得的期望回报；或表示为在当前策略 $\pi$ 下，衡量智能体所处状态 $s$ 时的价值大小. （状态 $s$ 的价值大小）

$$ V_{\pi}(s)=E_{\pi}[G_t\mid S_t=s]=E_{\pi}[R_{t+1}+\gamma R_{t+2}+\ldots\mid S_t=s]. $$

状态行为值函数 $Q_{\pi}(s,a)$：在执行策略 $\pi$ 时，针对当前状态 $s$ 执行某一具体行为 $a$ 所获得的期望回报.

$$ \begin{aligned}Q_{\pi}(s,a)&=E_{\pi}[G_t\mid S_t=s,A_t=a]\&=E_{\pi}[R_{t+1}+\gamma R_{t+2}+\ldots\mid S_t=s,A_t=a].\end{aligned} $$

模型

模型 $M$ 是智能体对环境的一个建模，以智能体的视角看待环境的运行机制，期望模型能模拟环境与智能体的交互机制. 通过给定一个状态和行为，使得该环境模型能够预测下一个状态和立即回报.
环境模型需要解决的问题
- 状态转换概率 $P^a_{ss'}$，预测下一可能状态发生概率;
- 预测可能获得的立即回报 $R^a_s$. $P^a_{ss'}$ 表征环境的动态特性，以预测在状态 $s$ 采取行动 $a$ 后，下个状态 $s'$ 的概率分布. $R^a_s$ 表征在状态 $s$ 上采取行为 $a$ 后得到的回报.

$$ \begin{aligned}& P^a_{ss'}=P(S_{t+1}=s'\mid S_t=s,A_t=a),\ & R^a_s=E[R_{t+1}\mid S_t=s,A_t=a].\end{aligned} $$

若 $P^a_{ss}$ 与 $R^a_s$ 已知, 即表示模型已知. 环境实际运行机制称为 环境动力学. 【注】模型不是必需(如蒙特卡洛, 时序差分)

监督学习、非监督学习、强化学习

监督学习： 需要人工给定标记，通过对具有标记的训练样本进行学习 非监督学习： 无须给定标记，通过对没有标记的训练样本进行学习 强化学习：训练样本(智能体与环境交互产生的数据)没有标记，仅有一个延迟回报信号

强化学习的分类

根据在解决强化学习问题时是否建立环境动力学模型，分为 模型方法 和 无模型方法 .

教材参考

邹伟 - 强化学习 - 清华大学出版社.