前 RL 书

\[\newcommand{\t}{\text} \newcommand{\cur}[1]{\left\{#1\right\}} \newcommand{\co}[2]{{\color{#1}{#2}}} \newcommand{\eps}{\epsilon} \newcommand{\E}{\mathop{\mathbb E}} \newcommand{\p}{\partial} \newcommand{\mat}[1]{\begin{matrix}#1\end{matrix}} \newcommand{\d}{\mathrm d} \]

本文是古代部分。

目录

• Imitation Learning
  • Introduction
  • Behavioral Cloning
  • DAgger
  • Conclusion
• MDP
  • Introduction
  • Value Iteration
  • Policy Iteration
  • Asynchronous Dynamic Programming
  • Conclusion
• Small Space RL
  • Introduction
  • Direct Evaluation (Monte Carlo Policy Evaluation)
  • Monte Carlo Control
  • Analysis: On Policy to Off Policy
  • Temporal Difference Learning
  • Adaptive Dynamic Programming
  • Q-Learning
  • SARSA
  • Analysis: Issues of Per Step
  • Analysis: Issues of Active
  • Optimistic Exploration
  • Double Q-Learning
  • Conclusion
• Large Space RL
  • Introduction
  • Approximate TD and Q-Learning
  • DQN
  • (Prioritized) Experience Replay
  • Freeze Target Q-Network and DDQN
  • Reward Clipping and More
  • Dueling Networks
  • Rainbow
  • Distributed RL
• Policy Based RL
  • Introduction
  • Discounted Policy Objectives
  • Average Policy Objectives
  • Policy Gradient
  • Analytical Policy Gradient
  • Finite Differences
  • Policy Gradient Theorem
  • Monte Carlo Policy Gradient (REINFORCE)
  • Actor-Critics
  • Tricks From DQN
  • Bias and Compatible Function Approximation Theorem
  • Conclusion
• Conclusion

Imitation Learning

*本章是后期所作，跳过不影响阅读。

Introduction

策略 (policy) \(\pi\) 描述决策的过程。可以是 \(\pi(a\mid o)\)，即看到 观察 (observation) \(o\) 并作出决策 \(a\)，或者是 \(\pi(a\mid s)\) 即看到 状态 (state) \(s\) 并作出决策 \(a\)。状态和观察的区别在于，真实先验存在的是状态，而我们只能观测到观察；给定状态，必然可以推出观察，但反之不亦然，常常存在无法重建状态的场合。

一般而言，决策总是含时的，所以状态和决策都会带上时间下标 \(t\)，即 \(\pi(a_t\mid o_t)\)。策略可以是确定性或非确定性的。

Behavioral Cloning

最平凡的思路是，收集很多 \((o,a)\) 的数据，然后直接用监督学习的方法嗯训。这就是朴素的 behavioral cloning。但是有效吗？不一定：含时的决策会累计误差，最终导致和数据集完全不同的 trajectory。这主要是 RL 的数据集违背了 DL 的 i.i.d. 性质：前一时刻的状态和决策直接影响之后时刻的动力学。

但是大力出奇迹后训出来的自动驾驶模型出人意料地好。给出的解释是，因为提供的数据是左中右三个视角的摄像机图片，所以小幅度偏移后的结果会被侧方相机 cover（直行时，左侧摄像机的 label 是右转，右侧摄像机的 label 是左转），由此正确处理了 o.o.d. 数据。

因此，总结为：

• 理论上，因为没有 i.i.d. 性质，行为克隆是不能要的。
• 但是，有数种方法可以修补：
  • 使用更好的数据采集-增强方法（人为引入错误数据以加强 exploration）。
  • 使用更强大、误差更少的基座模型。
  • 多任务学习，出人意料地会有好效果。
  • 在朴素的监督学习框架下做一些修改，例如 DAgger 算法。

不过，先定量地分析朴素行为克隆造成的累计误差的规模。具体地，我们在意的其实不是一个行为的 代价：只要这个决策造成的后果在训练集中被充分覆盖，我们有理由相信强大的基座模型可以把它扳回正轨，换言之 犯错是好的，因为模型可以从犯错中学习；我们真正在意的是行为导致 进入 o.o.d. 状态 的概率：o.o.d. 的状态不在数据集里，因此我们的策略如果没有足够的泛化能力，大概率无法处理。

可以发现，如果单步进入 o.o.d. 态的概率是 \(\eps\)，则长度为 \(T\) 的 horizon 导致 o.o.d. 的总时刻数的期望是 \(\eps T+(1-\eps)(\eps(T-1)+(1-\eps)\dots)=O(\eps T^2)\)（因为一旦某时刻 o.o.d. 了，我们认为接下来的所有时刻大概率都是 o.o.d. 的）。而一个平方级别的错误数是无法接受的。但是，这是一个 上界，实际情况并没有这么悲观。

另一个问题是 Markovian 的建模（\(a_t\) 仅依赖于 \(o_t\)）不一定符合人类专家的行为：人类是会学习的，是 Non-Markovian 的！所以也可以给模型提供全部历史观测以增强其能力。但是它也有问题：模型可能从历史观测中学习到虚假的相关性而不是逻辑。

还有一个问题是，假如使用 Gaussian 等对连续动作建模，则其一般难以处理多 mode 的场合（正如 VAE 的 Gaussian Bottleneck 不如 VQ Bottleneck）。一种方法是用更复杂的动作建模，例如 Gaussian Mixture（但是缺少扩展性），VAE 本身，或者 Diffusion（事实上，这个动作建模器正是一个经典的条件生成模型）。或者也可以离散化——但是高维的离散空间非常大，端到端离散化一般无法接受，所以一般采用自回归式离散化，逐维处理。

然后是多任务学习。比起训达成「某个」目标，例如到达某特定点的策略，不如训达成「某系列」目标，到达一系列特定点的策略，把这条轨迹的目标也当作输入传进策略，即 goal-conditioned BC。这种策略在理论分析上不一定优，但实际表现通常更好。

DAgger

我们知道朴素的 BC 会导致 o.o.d. 问题。那么如果我们被允许收集额外的标注数据，应当如何收集？因此就有 Dataset Aggregation (DAgger)。具体地，在当前 policy 跑出若干 trajectory 后，交给人类专家标注该 trajectory 下的专家行为，针对性提供高质量数据。

Conclusion

IL 的几个重要问题：

• 需要大量人工标注的专家数据，而这些数据通常难以获得。
• 专家对于某些场景（例如复杂控制）通常也难以提供数据。

所以需要能自行探索、搜集数据的 RL。

MDP

Introduction

Markov 决策过程 (Markov Decision Process, MDP) 由以下部件构成：

• 状态集合 \(S\)。
• 行为集合 \(A\)。
• 转移方程 \(T(s,a,s')\)：在 \(s\) 态，执行 \(a\) 操作，得到 \(s'\) 的 概率，即 \(P(s'\mid s,a)\)。这也被称作 model。
• 奖励函数 \(R(s,a,s')\)。
• 起始态，可能的终止态。

特别地，存在一些简化版的建模，其中奖励函数只与 \((s,a)\) 乃至只与 \(s\) 相关。易发现这些建模都是上述建模的子集。

MDP 中的 Markov 是指，操作的结果仅与当前态相关，与历史操作无关。即，

\[\Pr[S_{t+1}=s'\mid S_t=s_t,A_t=a_t,\dots,S_0=s_0]=\Pr[S_{t+1}=s'\mid S_t=s_t,A_t=a_t] \]

目标是造一个最优策略 \(\pi^*:S\to A\)，最大化期望奖励。

MDP 可以有一个 Expectimax 状的搜索树，其中的每个节点形如 \((s,a)\)，被称作 Q-state 或 action state。相反，如果取 \(s\) 本身作为节点，那么其直接就是 state。

MDP 中，因为终止态不一定存在，对 将来 收益就缺少比较，一个低收益循环和一个高收益循环，都能一圈圈地把收益叠到无穷，但显然后者更好。那么思想就很明确了：我们更偏好 即时收益；对于长远未来的收益，我们更少地关注。因此，对于序列 \(\cur{s_0,a_0,R_1,s_1,a_1,R_2,\dots}\)，可以定义自 \(t\) 时刻开始的 折扣效用 (discounted utility)

\[G_t=R_{t+1}+\gamma R_{t+2}+\gamma^2R_{t+3}+\dots \]

其中 \(\gamma\) 是常数。特别地，这保证任意序列的效用均不超过 \(\dfrac{R_\max}{1-\gamma}\)，其中 \(R_\max\) 是所有可达态中单步的最大效用。

此外，还有 有限视界 (finite horizon) 技巧，仅考虑 \(T\) 步的结果，但缺点是策略就必须含时了；吸收态 (absorbing state) 技巧，保证所有策略最终都会到达终止态。

最后，在很久以后，我们将会看到一个 平均收益 (average reward) 技巧，但以下如无特别注明，我们均默认使用折扣效用。

Value Iteration

如何求解 MDP？考虑 DP。定义 \(V^*(s)\) 为自 state \(s\) 开始的最优效用（不管这里的效用是哪一种）。

则有 Bellman 方程：

\[V^*(s)=\max_a\sum_{s'}T(s,a,s')[R(s,a,s')+\gamma V^*(s')] \]

特别地，如果我们能找到一个满足 Bellman 方程的量 \(V\)，则我们可以直接下结论：有 \(V(s)=V^*(s)\)。即，Bellman 方程可以作为一个条件判别式。

如何求解这个 DP？一个简单粗暴的方式是 value iteration，即重复迭代直到收敛：有

\[V_{k+1}(s)=\max_a\sum_{s'}T(s,a,s')[R(s,a,s')+\gamma V_k(s')] \]

可以发现，当收敛时，有 \(V_{k+1}(s)=V_k(s)\)，故其满足 Bellman 条件。

但是它真的收敛吗？会的。

把 \(V_{k+1}(s)=\max_a\sum_{s'}T(s,a,s')[R(s,a,s')+\gamma V_k(s')]\) 简写成 \(V_{k+1}\gets BV_k\)，其中 \(B\) 被称作 Bellman 算子。以下证明 Bellman 算子在无穷范数（即 \(\max\) 下）是 \(\gamma\)-压缩的。

引理：\(|\max_zf(z)-\max_zh(z)|\leq\max_z|f(z)-h(z)|\)。证明是容易的。

考虑对于一切 \(V,V'\) 证明 \(\|BV-BV'\|_\infty\leq\gamma\|V-V'\|_\infty\)。这等效于证明对于一切 \(s\)，都有 \(|(BV)(s)-(BV')(s)|\leq\gamma\|V-V'\|_\infty\)。

\[|(BV)(s)-(BV')(s)| \\=\left|\max_a\sum_{s'}T(s,a,s')[R(s,a,s')+\gamma V(s')]-\max_a\sum_{s'}T(s,a,s')[R(s,a,s')+\gamma V'(s')]\right| \\\leq\max_a\left|\sum_{s'}T(s,a,s')\gamma[V(s')-V'(s')]\right|\leq\gamma\|V-V'\|_\infty \]

于是可以保证 value iteration 的线性收敛。

注意到我们求解 Bellman 方程归根到底是为了构造最优策略 \(\pi^*:S\to A\)，而这是很简单的。

定义 \(Q^*(s,a)\) 为自 Q-state \((s,a)\) 开始的最优效用，也被称作 最优 Q-value (optimal Q-value)。

\(Q^*\) 有其转移式，即

\[Q^*(s,a)=\sum_{s'}T(s,a,s')[R(s,a,s')+\gamma V^*(s')] \]

在此基础上，可以将 Bellman 方程重写为

\[V^*(s)=\max_aQ^*(s,a) \]

不过只要有了 \(Q^*\)，就可以进行 policy extraction 步骤，有 \(\pi^*(s)=\arg\max_aQ^*(s,a)\)。

当然，也可以直接从 \(Q^*\) 的角度进行 Q-value iteration，即

\[Q^*(s,a)=\sum_{s'}T(s,a,s')[R(s,a,s')+\gamma\max_{a'}Q^*(s',a')] \]

其收敛性同样易证。

然而，不管是 value iteration 还是 Q-value iteration，它们都是等价的，且有同样的问题：

• 每轮都要 \(|S|^2|A|\) 跑，很慢。
• 每轮的 \(\max\) 很少改变。
• policy 常常在值之前很早就收敛了——而我们只需要 policy。

于是我们下一节有一种更适配的做法。

Policy Iteration

另一种想法是直接从某种可能非最优的确定性 policy \(\pi\) 出发，不断精进策略。可以先定义一个辅助的

\[V^\pi(s)=\sum_{s'}T(s,\pi(s),s')[R(s,\pi(s),s')+\gamma V^\pi(s')] \]

即在 \(\pi\) 策略下，自 \(s\) 出发的期望收益。

这种做法好就好在，它不再是一个含 \(\max\) 的、必须要 DP 的式子，而是一个简单的线性方程组，直接上工具即可解决。

我们自然希望不断优化 \(\pi\)。如何优化？直接从上一轮的 \(V^\pi\) 出发跑一个 policy extraction 即可！因此有如下的 policy iteration 方法：

• 初始化一个 \(\pi_0\)。这可以随机，不过如果你设得比较好，它可能收敛更快。
• 重复以下过程：
  • 使用 \(\pi_i\to V^{\pi_i}\) 的方式，进行 policy evaluation。
  • 使用 \(V^{\pi_i}\to\pi_{i+1}\) 的方式，进行 policy extraction。
• 如果任何一步有 \(\pi_{i+1}=\pi_i\)，即收敛，可以中止了。

有 Policy Improvement Theorem：只要下一步的 \(\pi'\neq\pi\)，则对于所有状态 \(s\) 均有 \(V^{\pi'}(s)\geq V^{\pi}(s)\)，且至少存在一处有 \(V^{\pi'}(s)>V^{\pi}(s)\)。

由 policy extration 的定义，必有

\[\sum_{s'}T(s,\pi'(s),s')[R(s,\pi'(s),s')+\gamma\co{red}{V^\pi(s')}]\geq V^\pi(s) \]

其中红色的部分同样可以代入该不等式，得到展开两步的式子；不断代入，在展开到无穷步时，其即收敛到 \(V^{\pi'}(s)\) 的定义了。于是有 \(V^{\pi'}(s)\geq V^{\pi}(s)\)。而如果有一步有 \(\pi'(s)\neq \pi(s)\)，我们只要强制 policy extraction 时，argmax 如果有多个，优先保留原先取值，那么在此处就必然取严格大于号，就说明至少有一处改进了。

那么因为不同 policy 数目有限，我们即可得一个更好的结论：policy iteration 在有限步内收敛至最优 policy。

当然，我们其实更关注其到底在多少轮里收敛，而不是对一个巨大的理论上界瞪眼。似乎有工作表明其收敛轮数是多项式级别的，不过几乎在所有实际应用中，这玩意都会在常数轮里收敛。

Asynchronous Dynamic Programming

在值迭代的场合，需要显式地维护新旧两个值数组。另一种策略是让更新变成 in-place 的，即按照某种策略选择一个 state 然后按照 Bellman 方程展开。其同样保证收敛：只要所有 state 都会被 i.o. 展开即可。

进一步，展开可以有所偏好，更偏好 Bellman 误差

\[\Delta V=\left|\max_a\sum_{s'}T(s,a,s')[R(s,a,s')+\gamma V(s')]-V(s)\right| \]

更大的状态。为了保证正确性，这个值必须实时计算，因此更新后要根据逆动力学重设所有前驱态的 \(\Delta V\)。

[!NOTE]

但是在 DQN 的 经验回放 的场合，因为效率问题，还是使用静态的更新。

Conclusion

解 MDP——不论你使用 value iteration 还是 policy iteration——都属于 offline planning：你需要知道完整的 MDP 信息，才能进行规划。

但是如果有未知信息呢？这就是所谓的 online planning 的范畴了。它不再是规划问题，而是一个学习问题了。

强化学习，堂堂登场！

Small Space RL

Introduction

graph TD A[Agent] -- Actions:a --> B[Environment] B -- State:s Reward:r --> A

RL 同样是在求解一个 MDP 问题，但区别是，model（即转移方程 \(T(s,a,s')\) 和奖励函数 \(R(s,a,s')\)）均未知。需要在作出尝试的同时，学习到这些信息。

注意，RL 方面的 model 指的是 对 agent 所处环境的建模，这一命名方式来自控制论和 DP 的传统，与其它 AI 领域的 model 截然不同。

按照是否通过与环境的交互来对 model 进行显式建模，RL 可以分成两种：

• Model-Based Learning：其对 model 进行估测，然后将其归结为一个传统 MDP 问题。
• Model-Free Learning：其不显式存储 \(T\) 或 \(R\)，而是直接估测 \(V\) 或 \(Q\)。

再额外定义一些术语。在状态 \(s\)，agent 作出行为 \(a\) 然后到达后继态 \(s'\)，获得奖励 \(r\)，这个四元组 \((s,a,s',r)\) 被称作一个 sample。agent 按照某种 policy 不断作出行为获得 sample 直到到达某个终止态，期间收集到的所有 sample 被称作一个 episode。一般需要收集到足够多 sample 或 episode 后，才能进行优化。

此外，还有一个同样常见的 trajectory 的术语。一般 episode 指的是一次完整的实验，而 trajectory 指的是这次实验的数据。在本文中，为了不增加术语的复杂性 其实就是懒得区分了 统一使用 episode。另一个常见的属于是 roll out

这又引申出三组对立的概念。

首先，根据学习目标，有如下分类：

• Passive Learning：需要一个输入的 policy \(\pi\)，且其目的仅仅是估测该 \(\pi\) 时的 \(V^\pi\) 和/或 \(Q^\pi\)，类似于 MDP 中的 policy evaluation。
• Active Learning：进行一个闭环的学习，直接 optimize 出一个合适的 policy \(\pi\) 出来。

其次，根据更新时机，有如下分类：

• Per Episode：必须使用完整的 episode 进行更新。在标准术语中，一般称作 Monte Carlo Methods——因为这些算法大多基于 Monte Carlo 估测。
• Per Step：只需要零散的 sample 即可。在标准术语中，一般称作 Temporal Difference Methods——来源于后文将介绍的同名基础算法，它是大多数此类算法的根底。

最后，无论是作 evaluation 还是作 optimization，其都依赖于 sample/episode 作为数据。产生这些数据的策略被称为 Behavior Policy，而这些数据用来对 Target Policy 作 Evaluation/Optimization。不同算法对这些数据的来源需求不同。

• On-Policy Learning：Behavior Policy 和 Target Policy 必须完全相同。
• Off-Policy Learning：可以不相同，唯一的要求是获得的数据尽量能覆盖所有 case 即可——它甚至可以是从不知道哪里翻出来的未知来源数据，此时 Behavior Policy 不存在或者与 Target Policy 完全无关。

无论是 On-Policy 还是 Off-Policy 的 Active Learning，如果 Behavior Policy 缺乏充分的探索，那么算法就很容易过早地收敛到局部最优解，而错过了全局最优解。因此，设计有效的探索策略至关重要。

以上四个维度互相组合，产生了多样的算法。特别地：

• 几乎所有现代方法，都是 Active、Per Step 的。另外两个类别，倒是两种方向的现代方法都有。
• 与此同时，Active 和 Per Step 方法总会内生一些问题，后文将详细阐述之。
• 此外，存在通用的将 On Policy 改造为 Off Policy 的方法，同样将在后文阐述。

最后，还有一个特殊的维度，在上一节最后略微提了一下：

• Offline Planning：所有的数据都在一开始提供，无法自主获取新数据。
• Online Planning：允许自行获取新数据。

下文提到的所有算法都是 Online 的；但是，有些算法同样允许 Offline（虽然效果肯定更差）。

Direct Evaluation (Monte Carlo Policy Evaluation)

Model-Free，Passive，Per-Episode，On-Policy。

非常蠢。按照 Monte Carlo 的思想，任何一个从 \(s\) 出发，遵照 \(\pi\) 直到某个终止态的 episode 的效用即是对 \(V^\pi(s)\) 的估测，于是直接跑多次取平均即可。当然，对于一次 \(s_1\to s_2\to\dots\to s_k\) 的 episode，其同时可以作为路径上每一个点的估测。

因为是 MC，所以必须 On-Policy 才能保证统计无偏。

Monte Carlo Control

Model-Free，Active，Per-Episode，On-Policy。

上述算法对应着 policy evaluation 的部分；那么只要再补上一个 policy extraction 的部分，它就升格为完整的 policy iteration 算法了。

注意到一个 episode 除了提供对 \(V^\pi\) 的估计外，还可以同时估算 \(Q^\pi\)，而有了后者就能作 policy extraction 了。这就是 Monte Carlo Control (MCC) 算法。

到这里，问题看上去和 MDP 中的 policy iteration 没有明显不同。但问题恰恰就出在这里：MCC 的数据来源于它自身的探索，那么很容易即陷入局部最优值，出现早期的一个 action 没有被探索，之后就一直不会尝试的问题。事实上，这是所有 Active 方法的共性。

自然存在一些解决方案，它们被统称为 Exploration-Exploitation 方法，将在后文着重论述。目前可以先把它想象为，一个 policy \(\pi\) 不会固定地在状态 \(s\) 作决策 \(\pi(s)\)，而是会结合历史 episodes，已经处理/维护的一众信息，乃至随机化，来给出一个 adaptive 的决策。但是，我们仍然可以使用一个 \(\pi\) 来描述之——尽管现在已经不能将它理解为一个简单的确定性函数了。

这种 Exploration-Exploitation 分析只在 Active 的时候需要。对于 Passive 的场合，仍然可以假装它是一个简单的确定性函数。

目前可以认为，对 \(Q^\pi\) 进行 policy extraction 时，可以加上一些修改，让提取出来的东西由确定性函数变成一个 Exploration-Exploitation 方法。

不管这个 \(\pi\) 是什么，我们都可以使用 MC 来估算其 \(V^\pi\) 与 \(Q^\pi\)，前提是获取的 episode 确实来自之。因此，MCC 仍然是一个 On-Policy 方法。

Analysis: On Policy to Off Policy

通过 Importance Sampling，可以强行将 MCC 改造为 Off-Policy 策略。

具体而言，假设要对服从 \(p(x)\) 的变量采样，但我们只有 \(q(x)\) 的生成器，则可以手动乘上 \(\dfrac{p(x)}{q(x)}\) 的权重。换句话说，\(\mathbb E_{x\sim p(x)}f(x)=\mathbb E_{x\sim q(x)}\dfrac{p(x)}{q(x)}f(x)\)。

这是一种通用的将 On 改造为 Off 的策略。

Temporal Difference Learning

Model-Free，Passive，Per-Step，On-Policy。

Direct Evaluation 使用的 Monte-Carlo 会导致需要的收敛次数比较多，效果不好。此外，它们必须把整个 episode 跑完（Per-Episode）才能计算回报，不仅效率低下，更在很多没有明确终止态的问题中压根无法实现。雪上加霜的是，其方差也很大，进一步加剧了训练的不稳定性。

Temporal Difference (TD) 对这些问题进行了关注，动态地利用每一步的信息，提高了收敛速率。

• 初始将所有位置设成 \(V^\pi(s)=0\)。

• 在某一步中，假设其从状态 \(s\) 执行了操作 \(\pi(s)\) 到达了状态 \(s'\) 并获得了 \(R(s,\pi(s),s')\)，则可以定义一个 TD target

  \[\t{target}_\t{TD}=R(s,\pi(s),s')+\gamma V^\pi(s') \]

  这可以被看做是 \(V^\pi(s)\) 的一个新估测。如何整合？EMA！

• 所以更新就有式子

  \[V^\pi(s)\gets(1-\alpha)V^\pi(s)+\alpha\cdot\t{target}_\t{TD} \]

  每获得一个 sample，就使用该式更新一次。

  另外还有一种理解方式是定义 TD error

  \[\t{error}_\t{TD}=\t{target}_\t{TD}-V^\pi(s)=R(s,\pi(s),s')+\gamma V^\pi(s')-V^\pi(s) \]

  然后更新即可直接写成

  \[V^\pi(s)\gets V^\pi(s)+\alpha\cdot\t{error}_\t{TD} \]

  我个人还是更喜欢将其视作 EMA，因此在下文中所有地方仍然只会提到 target 不会提到 error。

  但是在 某些场合，它会更有用。

• 这个 \(\alpha\) 也是一种学习率，在迭代过程中，理论上应该逐渐调小，满足所谓的 Robbins-Monro 条件（\(\sum\alpha_t\to\infty,\sum\alpha_t^2<\infty\)）；但是实际上，因为 model 和 reward 常常并非固定，为了动态适配新环境，常常直接选择 \(\alpha\) 为固定的小常数。

Adaptive Dynamic Programming

Model-Based，Active/Passive，Per-Step(?)，Off-Policy

其思想就是建模 model 并跑 MDP。你都有 model 了，那自然想 passive 就作 evaluation，想 active 就作 optimization。并且，你只要是个 sample 就能用来建模，所以是 Off-Policy 的。

因为 Passive 有点太 trivial 了，所以以下直接考虑 Active 的版本。

朴素算法：使用在每个 state \(s\) 执行操作 \(a\)（换句话说，进入 Q-state \((s,a)\) 后）到达 \(s'\) 的频率，进行归一化后，得到估测的转移方程 \(\hat T(s,a,s')\)。而奖励函数一般不需要近似——只要有一次成功转移，奖励函数就会被得到（当然，也可以考虑奖励函数是一个 distribution，那么这里是通过多次实验估测其期望）——不过这里还是给出一个 \(\hat R(s,a,s')\) 的记号来描述之。有了 \(\hat T,\hat R\)，那么这就是一个朴素的 Offline MDP 问题了。

上述 Offline 方法要求足够多的 sample 才能估测到正确的 \(\hat T(s,a,s')\)。在 Online 的场合，我们还是希望有一个 Behavior Policy 的，且其应该与我们的 Target Policy 挂钩，以获取更适合其体质的数据。

倘若直接令 Behavior = Target，那么自然和 MCC 一样，会陷入局部最小值。因此，我们还是需要在 Behavior 中引入前文提到但尚未展开的 Exploration-Exploitation 算法的。

然而，MDP 优化的 Target Policy 并非 Exploration-Exploitation 算法，所以这仍然是一个 Off-Policy 方法。最终得到如下流程：

• 使用 Behavior Policy 搜集一堆 samples，获取更准确的 \(\hat T(s,a,s')\) 和 \(\hat R(s,a,s')\)。

  这里强调了「一堆 samples」，是因为与 TD 不同——TD 一步的更新修改量非常少，因此可以每一步都修改 \(P\)。然而因为跑 MDP 消耗过大，因此不会有人每多一个 sample 就跑一遍 MDP 的。因此开头的 Per-Step 上打了问号。

• 使用当前的 model 运行 MDP，获取 Target Policy，然后对其作 Exploration-Exploitation 改造得到新 Behavior。

为什么 MCC 也使用了 Exploration-Exploitation，但它却是 On-Policy 的？

因为 MCC 获取数据的目的和 ADP 不同：前者就是在通过 MC 方法估测 \(Q^{\t{Behavior Policy}}\)，而后者过了一层 MDP 的中继。因此当我们谈论 Target Policy 时，前者能直接到 Behavior Policy，而后者就不行。

Q-Learning

Model-Free，Active，Per-Step，Off-Policy

我们已经见到了 passive 的 Direct Evaluation 和对应的 active 改造即 MCC；还有 passive 以及 active 两种模式的 ADP；如何把 passive 的 TD 也改造为 active 呢？关键就在于补上 policy extraction 的一环。

要想作 extraction 就要有 \(Q\)。Q-Learning 就是把 TD 从 value iteration 迁移到 Q-value iteration，得到

\[\t{target}_\t Q=R(s,a,s')+\gamma\max_{a'}Q(s',a') \\Q(s,a)\gets(1-\alpha)Q(s,a)+\alpha\cdot\t{target}_\t Q \]

以上规则用于优化 \(Q\)。

这里的 \(\alpha\) 的分析也同上，理论上应该收敛，实际上取固定小常数。

可以发现，上述算法对 sample 来源没有明显要求，只要保证其覆盖足够广就是能收敛的——但并非无偏。故其是 Off-Policy，且完全可以作 Offline Planning。

自然，我们还是希望使用 Online 模式的。同 ADP 的场合一样，其 Target Policy 就是 \(Q\) 可以 extract 出的 policy，为了避免局部最小值，要把它改造为 Exploration-Exploitation 的 Behavior Policy。故其仍然是 Off-Policy 的。

SARSA

Model-Free，Active，Per-Step，On-Policy。

需要跳转到后面把 Exploration-Exploitation 的分析看完再回头看该部分。放在此处是为了结构完整。

有时，我们也会想使用 On-Policy 算法，因为其更加保守而稳定，但这就需求对 TD target 的改造，让其可以直接学习具有 Exploration-Exploitation 策略的 Target Policy。

原始的 Q-Learning 使用下式

\[\t{target}_\t Q=R(s,a,s')+\gamma\max_{a'}Q(s',a') \]

也就是说，实际上对 \(Q(s,a)\) 产生贡献的是 \(a'=\arg\max_{a'}Q(s',a')\)。考虑产生贡献的五元组 \((s,a,R,s',a')\)，就会发现，\(s\to a\) 来自于 Behavior Policy，而 \(s'\to a'\) 来自于 Target Policy（即 \(\arg\max\)）。

只需要让 \(s'\to a'\) 这一步也遵循 Behavior Policy，使用得到的 \((s,a,R,s',a')\) 产生贡献

\[\t{target}_\t{SARSA}=R(s,a,s')+\gamma Q(s',a') \\Q(s,a)\gets(1-\alpha)Q(s,a)+\alpha\cdot\t{target}_\t{SARSA} \]

那么此时 Target 和 Behavior 即完全对齐，且可以为任意 Exploration-Exploitation 策略。这就是 State-Action-Reward-State-Action (SARSA) 算法，其是一个 On-Policy 算法。

上述 \(s'\to a'\)，理论上只需要模拟一遍流程即可（我们不需要其实际执行时得到的 \(R\) 值和后继态）；但是在实际应用中，我们一边使用新鲜出炉的 \((s,a,R,s')\) sample 来更新 \(Q\)，一边就要给出到达 \(s'\) 态后的下一步，因此 \(s'\to a'\) 可以不止于模拟，其结果正是到达 \(s'\) 后，用来生成下一个 sample 的 \(a'\) 的来源。

对比 Q-Learning 和 SARSA，我们可以得出如下粗略结论：

• On-Policy 更稳定保守，方差较低，通常在学习初期更安全。然而，在训练末期，其较之 Off-Policy 更难收敛到最优策略，通常要求 Exploration-Exploitation 本身也必须逐步优化并收敛到最优。
• Off-Policy 更激进。且因为其本身配套的迭代等流程往往就是为 Target 不等于 Behavior 设计的，强行让二者相等，反倒会出现效果不佳的现象。

Analysis: Issues of Per Step

所有的 TD-Based Per-Step 算法都有一个共通的问题：一个 episode 后期获得的奖励需要漫长的时间才能传递到前期访问的状态。存在两个简单的方法可以处理之：

• Trajectory Replay：存储整个 trajectory（或称 episode——前文已经提到，本文并不区分二者），然后用其跑多轮更新。
• Reverse Updates：在此基础上，倒转 episode，以倒序更新。

当然，这两种做法一定程度上破坏了 Per-Step 的「每个 sample 均更新」的性质，更像是 Monte Carlo 式方法了。

有没有平衡二者的方法呢？有的有的，就是 Multi-Step Returns，它是 Per-Step 与 Per-Episode 的平衡，一个 \(n\)-step returns 的 Q-target 是

\[\t{target}_{n\text{-step}}=R_{t+1}+\gamma R_{t+2}+\dots+\gamma^{n-1}R_{t+n}+\gamma^n\max_{a'}Q(s_{t+n},a') \]

其是 variance 与 bias 的平衡：\(1\)-step（即朴素 Q-Learning）依赖于不完美的近期 \(Q\) 值，因此具有高的偏差；与此同时，\(\infty\)-step（即 MCC）依赖于多步采样，因此具有高的方差。

Analysis: Issues of Active

在上面所有 Online Active 算法中，我们都在强调，为了保证整个局面都被探索而不至于限于局部最小值，Behavior Policy 需要使用 Exploration-Exploitation 策略，以避免陷入局部最小值。并且，这种策略还需要能简单地通过对 \(Q\)-extracted policy 改造获取。

这里强调 \(Q\)-extracted policy，是因为上述所有方法在获取新 policy 时，都是从 \(Q\) 提取出来的。

我们需要的策略被称作 Greedy in the Limit of Infinite Exploration (GLIE)，其在信息不足的前期倾向于 Explore，而在信息充足的后期倾向于 Exploit。

这不是我们模拟退火吗。

最简单的 GLIE 策略是 \(\eps\)-greedy：对于 \(Q\)-extracted \(\pi\)，以 \(1-\eps\) 概率服从当前 \(\pi\) 进行 Exploit，\(\eps\) 概率随机执行一个 action 进行 Explore。它确实能完整探索整个空间，但一旦学习完成，就还是会因为 \(\eps\) 而在最优解周围「抖动」。或许随时间调小 \(\eps\) 可以解决，但是因为收敛真的很慢，实际上都使用常数。

另一种思路是 Boltzmann Exploration

\[\Pr(a\mid s)=\dfrac{\exp(Q(s,a)/T)}{\sum_{a'}\exp(Q(s,a')/T)} \]

随时间调小 \(T\)，这下真成模拟退火了。

在前文提到的 SARSA 中，即可使用这两者来造 Exploration-Exploitation。

Optimistic Exploration

除了上述由 Target Policy 到 Behavior Policy 的转化外，还有一类策略会直接调整计算 Target 的方式，通过乐观地为未被充分探索的态赋以「较高的价值」的方式，来让 Target 本身具有 Exploration-Exploitation 能力，进而不需要区分 Target 和 Behavior，相当于变成了一个 On-Policy 方法（其实不一定，本节最后将进行一定讨论）。这些策略被统称为 Optimistic Exploration。

可以发现，SARSA 就采用了一种类似的策略——虽然它不一定通过乐观赋值实现，但总归是保证了 Target 的 Exploration-Exploitation 能力。下文也将介绍一种很类似 SARSA 的方法。

---

首先考虑其在 Model-Based 中的应用。一个简单粗暴的想法是，认为只要一个 Q-state 被访问的次数不足 \(N_e\)，就认为它的价值是 \(V_\max=R_\max/(1-\gamma)\)，即假设接下来所有步骤的收益均为 \(R_\max\) 时的最乐观收益。即，在乐观策略下的 \(V^+\) 满足

\[V^+(s)=\max_a\begin{cases}V_\max&(N(s,a)<N_e)\\\sum_{s'}\hat T(s,a,s')[\hat R(s,a,s')+\gamma V^+(s')]&(N(s,a)\geq N_e)\end{cases} \]

有理论证明，其与下述 Model-Based 的 R-MAX 算法是等价的：

• 初始化一个 optimistic model，其假设所有未被探索的行为（即 \(N(s,a)<N_e\) 的行为）都会被转移到一个特殊的 吸收态 \(s^*\)，并立刻获得 \(R_\max\) 的收益。
• 在该 model 上直接跑裸的 ADP，获取 Target Model。
• 直接令 Behavior = Target 获取新 samples，并使用之更新 model（如果其访问次数达到 \(N_e\)，则转而采用我们试出来的估测）。

在 PAC Guarantee 下，存在对应的 \(N_\eps\)（可以使用 Chernoff Bound 估算），使得 R-MAX 只需要多项式步决策即可将误差衰减到 \(\eps\)。由此我们声称，RL 存在多项式近似算法！

---

在 Q-Learning 场合，则有以下 Exploration Function 模式：将原始 Q-Learning 中的

\[\t{target}_\t Q=R(s,a,s')+\gamma\max_{a'}Q(s',a') \]

替换为

\[\t{target}_\t{EF}=R(s,a,s')+\gamma\max_{a'}f(s',a') \]

其中

\[f(s',a')=Q(s',a')+\text{exploration bonus} \]

就是 Exploration Function，其为常规的 \(Q\) 加上一个针对未探索过的态的奖励。有使用 \(k/N(s',a')\) 或 \(k/\sqrt{N(s',a')}\) 的，其中 \(k\) 是常数，\(N\) 是累计访问次数。也有一步到位直接使用我们 MCTS 中 UCB 函数的。而生成 \((s,a,R,s')\) 的 Behavior Policy 直接选择 \(f\) 的 argmax。

我们发现，其相当于生成了一个 \(a'=\arg\max_{a'}f(s',a')\)，然后使用 \((s,a,R,s',a')\) 计算

\[\t{target}_\t{EF}=R(s,a,s')+\gamma f(s',a') \]

……等一下，这个生成 \(a'\) 的过程，不就是 Behavior Policy？那它不就是 SARSA……吗？

其与 SARSA 的唯一不同，在于 SARSA 的 target 中使用的是 \(Q\) 而不是 \(f\)。

但使用不完全对齐的 SARSA 模式其实是更合理的，因为如果仅使用 Exploration Function，那么就又踏入那种我们一开始就批判过、会陷入局部最小值的「Target = Behavior」模式的老路，无非是优化目标从 \(Q\) 换成 \(f\) 罢了。

因此，Exploration Function 常常还要额外搭配 \(\eps\)-greedy 或 Boltzmann Exploration 使用，而不是直接使用 \(f\) 的 argmax。可以看到，这种做法其实仍然保有 Off-Policy 的可能性，而不是 SARSA 那种「完全适配 On-Policy」模式。

Double Q-Learning

朴素的 Q-Learning 存在一个问题：我们的 target 满足下式

\[\t{target}_\t Q=R(s,a,s')+\gamma\max_{a'}Q(s',a') \]

这里的 max 算子是罪魁祸首，因为 \(\E[\max(a,b)]\geq\max(\E[a],\E[b])\)，最终得到的 target 会大于实际上的期望值。长此以往，所有 \(Q\) 值就会出现一个 系统性高估。如果这个高估出现在一个次优态上，那么即可能导致其被偏好；而最糟糕的场景下，该高估会让训练振荡乃至发散。

Double Q-Learning 将 选择最优策略 和 评估该策略的效果 解耦——两个策略同时因为噪声高估一个行为的概率是小的。其维护了两个完全独立的 \(Q\) 表 \(Q_1,Q_2\)，对于一个 sample \((s,a,R,s')\)，其从 \(Q_1,Q_2\) 中随机选一个，以选中 \(Q_1\) 时为例，则使用下式更新之：

\[\t{target}_{\t{DoubleQ}}=R+\gamma Q_2(s',\arg\max_{a'}Q_1(s',a')) \\Q_1(s,a)\gets(1-\alpha)\cdot Q_1(s,a)+\alpha\cdot\t{target}_\t{DoubleQ} \]

即，使用 \(Q_1\) 选择最优策略（argmax），然后使用 \(Q_2\) 评估之。这样做把 \(Q_2\) 的评估结果融合到 \(Q_1\) 中，避免 \(Q_1\) 一直 bootstrapping 式地累积高估。同理，如果选中 \(Q_2\)，则二者地位互换。

最终使用的 policy（例如 Behavior Policy）可以通过综合 \(Q_1,Q_2\) 的效果得到，例如直接将二者取平均后套 Exploration-Exploitation。

这个方法在离散 Q-Learning 的场合，需要两倍的代价（同时优化 \(Q_1,Q_2\)），因此应用有限。而在下一章的 DQN 中，因为可以与另一个常见技巧结合，代价被降低了，所以成为了如今非常主流的优化策略。

Conclusion

• On Policy 加上一个 importance sampling 就变成了 Off Policy。
• Per Episode 不适用于没有终止态的场合。Per Step 则在状态传播上效率受限。
• Passive 维护 \(Q\) 并加上一个 policy iteration 就变成了 Active。但后者需要好的 Exploration-Exploitation 策略。
• Exploration-Exploitation 分为修改行为策略和修改目标策略两种模式，且可以结合使用。

Large Space RL

Introduction

虽然上述理论看着很棒，但是实际的 RL 问题有太多 state 和太多 action，访问所有态或是储存所有 \(V\) 和 \(Q\) 值变得不可能。但是同时，将其看成离散的「表格」，是一种很僵硬的行为：相似的 state 或许拥有借鉴意义呢？

于是一种想法是把状态空间映射到一个更小的空间，相似的状态可以映到小空间里的同一个态。存在一些方法处理之，但并非重点。

Approximate TD and Q-Learning

更常见的思路是直接用参数化的函数 \(\hat V_\theta(s)\) 和 \(\hat Q_\theta(s,a)\) 来表示之，以期待模型在收到输入时，能给出一个好的 \(Q\) 值预测。

使用什么函数来参数化？在前神经网络时代，可能会使用一堆特征提取器 \(f_i(\cdot)\) 然后直接 \(f_\theta=\sum\theta_if_i(\cdot)\)。是不是很熟悉？Alpha-Beta Pruning 中的评估函数也干了。当然我们还是更希望一些 general 的结果的。

在 TD 的场合，我们原本希望 \(V^\pi(s)\) 靠近 \(\t{target}_\t{TD}=R(s,\pi(s),s')+\gamma V^\pi(s')\)，并使用 EMA 整合二者。

那么现在在近似 TD 的场合，我们同样希望 \(\hat V_\theta(s)\) 靠近 \(\t{target}_\t{TD}=R(s,\pi(s),s')+\gamma \hat V_\theta(s')\)。因为参数化了，所以可以直接用更泛化的距离度量来设置误差，加上 GD 即得公式

\[\theta'=\theta-\eta\nabla\text{dist}[\t{SG}(\t{target}_\t{TD})-\hat V_\theta(s)] \]

其中 \(\t{SG}(\cdot)\) 是停止梯度回传操作，把 \(\t{target}_\t{TD}\) 当成 bootstrapping 的样本，而 \(\t{dist}\) 是某种距离度量，一般取 MSE \(\dfrac12\|\cdot\|^2\) 即可。

换句话说，这里其实是把 TD error 当作需要最小化的量进行训练，当然其中的 target 部分需要停止回传。

同理在 Q-Learning 的场合，我们原本使用 EMA 整合 \(\t{target}_\t Q\)，现在同样直接套度量求梯度即可。

DQN

Deep Q-Network (DQN) 就是使用神经网络刻画 \(\hat Q_\theta(s,a)\) 然后使用 DL 开训的 Q-Learning。

……但不仅仅是。与表格式的 Q-Learning 不同，参数式的 DQN 因为神经网络自身性质，很容易「牵一发而动全身」。首先有两个最致命的问题：

• agent 收集到的 episode 不是 i.i.d. 的——其依赖于当前所处状态，相邻数据具有很强的相关性。而梯度下降，这个来自 ML 的强力优化手段，完全依赖于 i.i.d. 的前提。而在朴素 Q-Learning 的场合，就算数据具有内在的 pattern，某些 state 被刻意地强调，但因为各个 state 彼此独立，对其修改并不会外溢到其它位置，因此当时这并不是什么大问题。
• Target 由该训练网络自身生成，而「自己追赶自己」，很容易导致振荡乃至发散，同时也会反过来进一步加剧数据的非 i.i.d. 性——\(Q\) 值的轻微变化就可能导致 policy 的剧变。而在朴素 Q-Learning 的场合，其收敛性有理论保证，因此不成问题。

除了这两个核心问题外，还有一个次要问题，就是 Reward 的值域不能事先假定，而如果它们过大，很容易直接一个 BP 就给你梯度爆炸了。

解决了这些问题，才能得到一个能要的网络出来。在此基础上，还有针对网络结构的设计，以及与前一节中提到的某些手段（其实这些手段都是在 DQN 中才真正被发扬光大，只不过因为它们对朴素 Q-Learning 同样也有效，所以被我丢到前一节去了）的结合，以获得更好的效果。

(Prioritized) Experience Replay

解决不具有 i.i.d. 性质的方法很简单：虽然数据流不是 i.i.d. 的，但是我们可以对历史 sample 建一个 replay buffer，每次从中随机挑一个 batch 当作数据不就行了？这同时也解决了因为 policy shift 导致的数据剧变问题。这种被称作 Experience Replay 的方法如今已经成为各种神经网络方法的基石。

当然，有些人还嫌这个效果不够好。比如说，那些带来较大误差也即 \(\|Q-\t{target}\|\) 较大的数据，它们应该更值得被学习。设置与误差挂钩的权重并以之从 replay buffer 中采样，此乃 Prioritized Experience Replay。

如何设置权重？直接取 argmax 显然是不好的。那 softmax，即对误差求 exp 然后归一化呢？因为 RL 本身就是一个不稳定的过程，误差的范围可能很大，exp 效果不会很好。所以更稳定的做法是直接求幂函数，对误差求 \(\alpha\) 次幂然后归一化，其中 \(\alpha\) 是超参数。

另一个问题是，一个 sample 的误差会随着模型的演进动态变化，而显然不能在每次模型更新后重新计算所有误差。因此典型做法是保留该 sample 上次被用于训练时得到的误差，就算某个 sample 的误差因为模型演化变得不准了，把它拿出来训一遍它就又准了。当然，新生成的 sample 是没有误差的，因此普遍做法是在其生成后立刻用之训练（换句话说，给新 sample 最高的优先级）。

至于如何关于归一化权重采样，可以简单使用平衡树等达到对数复杂度。但是因为实现有一定难度，且需要调更多参，所以一般在原型验证时不用它。

Freeze Target Q-Network and DDQN

解决 Target 问题也很简单：直接从一个冻结了的历史版本模型获取 Target 不就行了？这就是 Freeze Target Q-Network。当然为了严谨，还是来定义一些专有名词吧。

我们的训练对象被称作 online network 或 main network 或 policy network。而那个被冻结的历史版本，因为它提供 target，所以直接被称作 target network。

早期工作会使用 hard update，即每隔固定间隔就用 main network 刷新一次 target network，现在全用 soft update 也即 EMA 了（笑）。

---

前一节中提到了为解决 Q-Learning 的系统性高估问题，提出了 Double Q-Learning，但是因为要同时优化两个网络，它的效果并不是很好。但是在 DQN 的场合，我们天生就有两个网络，因此可以将 Double Q-Learning 的思想糅合进来，对于即主网络 \(Q_\theta\) 和目标网络 \(Q_{\theta'}\)，使用下式更新

\[\t{target}_{\t{DoubleDQN}}=R+\gamma Q_{\theta'}(s',\arg\max_{a'}Q_\theta(s',a')) \\\theta\gets\theta-\eta\nabla\|Q_\theta(s,a)-\t{SG}(\t{target}_\t{DoubleDQN})\|^2 \]

这就是 Double DQN (DDQN) 的核心思想。

现如今，Freeze Target + DDQN 同样也成为标配了。

Reward Clipping and More

为了处理 reward 爆炸的问题，早期工作会使用简单粗暴的 Reward Clipping：将 reward 裁剪到某个固定范围中。但是与 DL 中如今仍大行其道的 Gradient Clipping 不同，Reward Clipping 扭曲了激励（而 Gradient Clipping 并没有改变梯度的方向），所以在很多问题上效果不佳，如今已销声匿迹。

取而代之的是例如除以常数的 reward scaling、batch normalization 乃至关于累计信息的 return normalization 等方法。除此之外，将 MSE 换成更稳定的 Huber Loss 等也有助于缓解因为 Reward 问题导致的梯度爆炸等。

Dueling Networks

现在来看网络结构。Dueling Networks 基于一个重要的假设，即同一个 \(s\) 下的所有 \(Q(s,a)\) 具有一定的关联性：如果对其中一者评价较高，那么对它者的评价亦然。对于绝大多数 RL 问题而言，这确实是成立的。

于是将 \(Q(s,a)\) 拆成二者之和：state value \(V(s)\) 和 action advantage \(A(s,a)\)，并希望有

\[Q(s,a)=V(s)+A(s,a) \]

注意，此处的 \(V(s)\) 与 MDP 时的 \(V\) 并不一样——在 MDP 语境下，\(V(s)=\max_aQ(s,a)\)；而此处的 \(V(s)\) 则更像是全体 \(Q(s,a)\) 的一种平均。

但是光凭上式不能唯一确定 \(V(s)\) 的取值：完全可以对 \(V(s)\) 加上一个 \(\Delta\) 并将全体 \(A(s,a)\) 减去同样的 \(\Delta\) 得到另一组解。因此实际上采用的式子是

\[Q(s,a)=V(s)+A(s,a)-\operatorname*{avg}\limits_{a'}A(s,a') \]

这个时候两边取平均即得 \(V(s)=\operatorname*{avg}\limits_{a'}Q(s,a')\)，成为严格意义上的平均了。

实际上有人把 avg 换成 max，据说这样会更稳定？

那么现在参数化后，就使用 \(Q_\theta(s,a)=V_\theta(s)+A_\theta(s,a)-\operatorname*{avg}\limits_{a'}A_\theta(s,a')\) 的方式来建模 \(Q\) 函数，这样 \(Q(s,a)\) 受到的激励会通过反向传播同时抬升 \(V\) 和 \(A\) 两者，符合我们的设计预期。同时，\(A\) 和 \(V\) 可以是同一个特征提取网络上接的两个头，因此复杂度并没有提升太多。

该方法只是一个可选的改造项，在某些更关注状态价值的任务上效果很好，而存在一些非常病态的问题（\(Q(s,a)\) 高度依赖于 \(a\)）效果不佳。

Rainbow

Rainbow 是一个各种 trick 的集大成者，它使用了以下方法：

• Prioritized Experience Replay。
• DDQN。
• Dueling Networks。
• 上一节在讲 Per-Step Issue 时提到过的 Multi-Step Returns 方法。
• Distributional RL：要求模型不止预测 \(Q(s,a)\) 的期望，更需要进一步预测整个分布（例如，将值域切分为离散的范围，然后预测收益落入各个范围的概率）。现今仍然在 Value-Based 方法中被广泛使用。
• Noisy Nets for Exploration：通过直接在网络的参数（通常是全连接层的参数）中加噪音来实现随机探索。优于 \(\eps\)-greedy。在 Value-Based 方法中基本上成为惯例。

这里的 Value-Based 是什么？等会就知道了。

Distributed RL

注意与 Rainbow 中的 Distributional RL 区分。

如果 agent 存在于虚拟世界中，它可以比较迅速地获取样本；但是，对于实存的 agent，它获取样本的效率远小于 GPU 开训的效率。因此一个 Learner 加上众多 Actor 的模式成为标准。（其实就是一种变相的 Data Parallelism）

Policy Based RL

Introduction

目前为止，我们提到过的所有方法，都是 Value-Based 的方法。这些方法的核心对象是 \(V\) 或 \(Q\)，而 policy 通过从中提取得到。这甚至包括 MDP 中的 policy iteration 方法，因为它同样包括一步 policy extraction。

当然，ADP 和 R-MAX 一般直接被视作 Model-Based，因为它们的理念是规约到 MDP，算法本身并没有显式地使用任何 value 或 policy。至于归约到 MDP 后使用什么方法，就不是这两个算法自身的问题了。

除此之外，还存在一类 Policy-Based 方法，它直接建模 \(\pi_\theta(s,a)\) 为在态 \(s\) 执行动作 \(a\) 的概率。可以使用 Gaussian 或 softmax 建模。当然有时我们不想使用非确定性方法，此时也可以直接建模为 \(\mu_\theta(s)\)。

还存在一类同时 建模 Policy 和 Value 的方法（Actor-Critic），将在后文讨论。

为什么这里的建模被强调了呢？参考

但首先我们要思考，为什么需要 Policy-Based 方法？

• 能很自然地处理连续空间场合。例如，我们可以使用 Gaussian 的均值和方差等描述 \(\pi_\theta\)。
• Value-Based 通过 policy extraction 得到的策略一般都是确定性策略。但是我们有时还是需要随机策略的（例如剪刀石头布）。
• 更平滑，没有策略突变（反观 DQN，虽然我们通过 Experience Replay 去除了其对训练稳定性的影响，但策略突变仍然存在）。

当然其也存在一些显著的缺点，将在详细介绍完具体方法后说明。

正因为 Policy-Based 和 Value-Based 各有重大缺陷，二者融合也即 Actor-Critic 现在成为了 RL 的主流。

不其实 Actor-Critic 的本质还是 Policy Based，而且它也没那么主流了。

Discounted Policy Objectives

首先要造一个 objective 出来。

在 episodic environment 也即存在明确终止态的环境下，我们采取 start value

\[J_1(\theta)=\E_{s_0\sim h(\cdot)}V^{\pi_\theta}(s_0) \]

其中 \(h\) 是起始态分布。

但是在 continuing environment 也即不存在明确终止态的环境下，随着时间延长，初始态的重要性被稀释。所以我们更关注 average value

\[J_\t{avV}(\theta)=\E_{s\sim d^{\pi_\theta}(\cdot)}V^{\pi_\theta}(s) \]

其中 \(d\) 为 stationary distribution。

注意区分：continuing 与 continuous 是两个不同概念，后者与 discrete 相对。

这两种都建立在 discounted environment，也即使用了 discounted factor \(\gamma\) 以防止 \(V^{\pi_\theta}\) 爆炸的场合。

Average Policy Objectives

但是有时我们不想使用 discounted factor，此时问题就变为 average reward environment，因为我们使用的是 average reward per-step：

\[J_\t{avR}(\theta)=\E_{\mat{s\sim d^{\pi_\theta}(\cdot)\\a\sim\pi_\theta(s,\cdot)}}\sum_{s',r}\Pr[s',r\mid s,a]r \]

即在 \(\pi\) 的指引下，进行一步操作的期望收益。这个收益也被直接写作 \(r(\pi_\theta)\)。

但是你不能光给个 loss 的定义就跑了——现在没有 \(\gamma\)，我们原本的 \(V,Q\) 就全部没有意义了，甚至两次迭代的优劣也根本无法比较（它们都发散了），在此基础上定义的 TD、Q-Learning 等一系列理论大厦轰然倒塌，因此新手段确有必要。

所以之后在讨论问题时，要注意看我们在什么环境下讨论：假如使用的是 \(J_1,J_\t{avV}\)，则我们在讨论的是 discounted utility；而若使用的是 \(J_\t{avR}\)，则在讨论的则是 differential utility。

此时我们使用的是自 \(t\) 时刻开始的 差分效用 (differential utility)

\[G_t=R_{t+1}-r(\pi)+R_{t+2}-r(\pi)+\dots \]

其衡量其相对于平均价值的好坏。

这个技巧在很久以前讨论 MDP 时挖过坑，现在来填坑了。

那么现在把原来的更多概念迁移过来。

\[\mat{ V^\pi(s)=\E[G_t|s_t=s] \\Q^\pi(s,a)=\E[G_t|s_t=s,a_t=a] \\V^\pi(s)=\E_{a\sim\pi(s,\cdot)}\sum_{s',r}\Pr[s',r\mid s,a][r-r(\pi)+V^\pi(s')]&(\t{Bellman}) \\Q^\pi(s,a)=\sum_{s',r}\Pr[s',r\mid s,a][r-r(\pi)+\E_{a'\sim\pi(s',\cdot)}Q^\pi(s',a')]&(\t{Bellman}) \\\t{target}_\t{TD}=R_{t+1}-\bar R+V^\pi(s') \\\t{target}_\t{SARSA}=R_{t+1}-\bar R+Q^\pi(s',a') } \]

这里的 \(\bar R\) 是 \(r(\pi)\) 的估计，一般以一个远小于 TD/SARSA \(\alpha\) 的学习率 \(\beta\) 进行更新。

注意到这里我们并没有给出 Q-Learning 的 Target，因为此处的语境是 policy-based 方法，TD 和 SARSA 因为是 on-policy 的所以还可以改造，但 Q-Learning 这种 off-policy 且 extract 出来的 policy 是 argmax 的东西，要让它适配当前语境会比较困难（虽然确实可行），因此不作讨论。

Policy Gradient

不管怎么说，我们有 objective 了，那么直接 gradient ascent（注意到要最大化 \(J\)）即可……吗？这个 objective 一点也不像是可微的样子。

因此，Policy Based RL 的一个核心任务就是去计算或估算 \(\nabla J\)，这个任务被称作 policy gradient。

Analytical Policy Gradient

这是在最基础的 MDP 场合使用的算法，是一切 Policy Based 方法的原型。此时因为 model 已知，可以直接通过线代等求出 \(d\) 的解析解，进而得到精确梯度。当然对于存在精确方法（value/policy iteration）的 MDP，将其连续化并使用 GD 并不是一个好主意（又麻烦又慢），所以其并非解决 MDP 的主流方法。

Finite Differences

现在来到 RL，则求出精确 \(\nabla J\) 是不太现实的。

一种手法是使用愚蠢的

\[\dfrac{\p J(\theta)}{\p\theta_i}\approx\dfrac{J(\theta+\eps\cdot e_i)-J(\theta)}{\eps} \]

来估测每一维的梯度，此乃 Finite Difference Policy Gradient。但显然太过粗暴，没人会想用它——不过在某些简单的特定场合还是勉强能用的。

Policy Gradient Theorem

来点数学式子。首先先处理 discounted environment。

\[\nabla_\theta V^{\pi_\theta}(s)=\nabla_\theta\sum_{a\in A}\pi_\theta(s,a)Q^{\pi_\theta}(s,a) \\=\sum_{a\in A}\nabla_\theta\pi_\theta(s,a)\cdot Q^{\pi_\theta}(s,a)+\sum_{a\in A}\pi_\theta(s,a)\nabla_\theta Q^{\pi_\theta}(s,a) \]

这里我们再次请出我们的 score function \(\nabla\log\pi_\theta(s,a)=\dfrac{\nabla\pi_\theta(s,a)}{\pi_\theta(s,a)}\)——其在化解这类与概率期望相关的梯度问题时特别有用。代入同时展开 \(Q\) 即得

\[\\=\sum_{a\in A}\pi_\theta(s,a)\nabla_\theta\log\pi_\theta(s,a)\cdot Q^{\pi_\theta}(s,a)+\sum_{a\in A}\pi_\theta(s,a)\nabla_\theta\sum_{s',R}\Pr[s',R\mid s,a](R+\gamma V^{\pi_\theta}(s')) \\=\sum_{a\in A}\pi_\theta(s,a)\nabla_\theta\log\pi_\theta(s,a)\cdot Q^{\pi_\theta}(s,a)+\gamma\sum_{a\in A}\pi_\theta(s,a)\sum_{s'}\Pr[s'\mid s,a]\nabla_\theta V^{\pi_\theta}(s') \]

于是定义 \(\rho^{\pi_\theta}(s\to t,k)\) 为遵照 \(\pi_\theta\) 策略，在恰 \(k\) 步时自 \(s\) 到达 \(t\) 的概率，于是即有

\[=\sum_{a\in A}\pi_\theta(s,a)\nabla_\theta\log\pi_\theta(s,a)\cdot Q^{\pi_\theta}(s,a)+\gamma\sum_{s'}\rho^{\pi_\theta}(s\to s',1)\nabla_\theta V^{\pi_\theta}(s') \]

现在不断重复展开，即得

\[=\sum_t\left(\sum_{k=0}^\infty\gamma^k\rho^{\pi_\theta}(s\to t,k)\right)\sum_{a\in A}\pi_\theta(t,a)\nabla_\theta\log\pi_\theta(t,a)\cdot Q^{\pi_\theta}(t,a) \]

现在来定义一些辅助量。

对于任何初始分布 \(h(s)\)，定义 \(\eta(s)\) 为其在所有游走经历中，游走至 \(s\) 的带权次数，则有

\[\eta(s)=h(s)+\gamma\sum_{s'}\eta(s')\sum_a\pi_\theta(s',a)\Pr[s\mid s',a] \]

通过解方程可以由任何初始分布解出 \(\eta\)，然后归一化后得到的分布称作 \(\mu(s)\)。无论是 episodic 还是 continuing 甚至 average return（此时认为 \(\gamma=1\)），上述定义均有效，不同的是前者 \(\mu\) 与初始分布 \(h\) 相关，而后两者只要迭代是 ergodic 的则 \(\mu\) 就是 stationary distribution \(d^{\pi_\theta}\)，与初始分布 \(h\) 无关。

而 \(\eta\) 的另一种计算方法即为

\[\eta(s)=\sum_{t}h(t)\sum_{k=0}^\infty\gamma^k\rho^{\pi_\theta}(t\to s,k) \]

可以发现，其刚好与上述对 \(\nabla_\theta V^{\pi_\theta}(s)\) 的推导中的系数拥有相同形式。于是套一层关于 \(s\) 的分布采样，即知有

\[\nabla_\theta J_1(\theta),\nabla_\theta J_\t{avV}(\theta)\propto\E_{\mat{s\sim \mu(\cdot)\\a\sim\pi_\theta(s,\cdot)}}\nabla_\theta\log\pi_\theta(s,a)\cdot Q^{\pi_\theta}(s,a) \]

因为我们只在意梯度的方向，所以知道正比于就够了。

---

现在再考虑 average reward environment。此时推导可以复用至展开 \(Q\) 的一步

\[\nabla_\theta V^{\pi_\theta}(s)=\sum_{a\in A}\pi_\theta(s,a)\nabla_\theta\log\pi_\theta(s,a)Q^{\pi_\theta}(s,a)+\sum_{a\in A}\pi_\theta(s,a)\nabla_\theta\sum_{s',R}\Pr[s',R\mid s,a](R-r(\pi_\theta)+V^{\pi_\theta}(s')) \\\nabla_\theta r(\pi_\theta)=\sum_{a\in A}\pi_\theta(s,a)\nabla_\theta\log\pi_\theta(s,a)Q^{\pi_\theta}(s,a)+\sum_{a\in A}\pi_\theta(s,a)\sum_{s'}\Pr[s'\mid s,a]\nabla_\theta V^{\pi_\theta}(s')-\nabla_\theta V^{\pi_\theta}(s) \]

注意到左侧与起始态 \(s\) 无关，于是右式同理，故可以关于 \(\mu(s)\) 也即 stationary distribution 求和，则两个 \(\nabla_\theta V^{\pi_\theta}(\cdot)\) 刚好抵消掉了，于是只剩下

\[\nabla_\theta J_\t{avR}(\theta)=\sum_s\mu(s)\sum_{a\in A}\pi_\theta(s,a)\nabla_\theta\log\pi_\theta(s,a)Q^{\pi_\theta}(s,a) \]

于是整理可得

\[\nabla_\theta J(\theta)\propto\E_{\mat{s\sim \mu(\cdot)\\a\sim\pi_\theta(s,\cdot)}}\nabla_\theta\log\pi_\theta(s,a)\cdot Q^{\pi_\theta}(s,a) \]

的式子对 \(J_1,J_\t{avV},J_\t{avR}\) 均成立，这就是 Policy Gradient Theorem。

但需要注意，这里 \(\mu\) 和 \(Q^{\pi_\theta}\) 的定义在不同场合不同：

• \(J_1\) 的场合是从起始分布 \(h\) 出发按照 \(\gamma\) decay 的遍历分布和 discounted \(Q\)。
• \(J_\t{avV}\) 的场合是 stationary distribution 和 discounted \(Q\)。
• \(J_\t{avR}\) 的场合是 stationary distribution 和 average return \(Q\)。

Monte Carlo Policy Gradient (REINFORCE)

有了一个带期望的式子，我们自然会想用 Monte Carlo 估算它。这就是著名的 REINFORCE 算法。

其流程如下：

• 收集一个 episode \(\tau=(s_0,a_0,r_1,\dots,s_{T-1},a_{T-1},r_T)\)。
• 枚举 \(t\)，计算 \(G_t=r_{t+1}+\gamma r_{t+2}+\dots\) 作为 \(Q^{\pi_\theta}(s_t,a_t)\) 的估测，然后更新 \(\theta\gets\theta+\alpha\co{red}{\gamma^t}G_t\nabla\log\pi_\theta(s_t,a_t)\)。

注意这里标红的 \(\gamma^t\)。目前的式子完美符合上文中从 \(\mu\) 中采样的过程，估测是无偏的；但是这样做会让远处的贡献几乎为零，收敛起来会很慢。因此实践时我们通常直接把这个系数丢掉，这样相当于在每一时刻均最大化剩余回报 \(G_t\)，因此收敛更快，最终性能也往往更好。

换言之，其使用的公式可以写作

\[\nabla_\theta J(\theta)\propto\E_{\tau\mid\pi_\theta}\sum_{i=0}^{T-1}\nabla_\theta\log\pi_\theta(s_i,a_i)\sum_{t=i+1}^Tr_t \]

当然，因为使用了 Monte Carlo，其天生带有以下弊端：

• 高方差。
• 只能处理 episodic 的任务。

那么有没有不带 MC 的方法呢？有的有的，就是 Actor-Critics。

Actor-Critics

我们需要 \(Q^{\pi_\theta}(s_t,a_t)\) 的估测。为什么非得用 MC 呢？之前学过好多 policy evaluation 的方法，直接建个模然后 eval 不就行了？

于是就有如下的 Q Actor-Critic 方法：

• Actor \(\pi_\theta(s,a)\) 刻画策略，Critic \(Q_\varphi(s,a)\) 刻画 \(Q^{\pi_\theta}(s,a)\)。

• 对于收集到的 sample \((s_t,a_t,r_{t+1},s_{t+1},a_{t+1})\)：

  • Actor 使用 \(\theta\gets\theta+\alpha Q_\varphi(s_t,a_t)\nabla\log\pi_\theta(s_t,a_t)\) 更新。

  • Critic 使用正常的 SARSA Target \(\t{target}_\t{SARSA}=r_{t+1}+\gamma Q(s_{t+1},a_{t+1})\) 更新。

    这里虽然挂的名字是 Q，但实际上用的是 SARSA 那一套，原因还是因为 on-policy 的 SARSA 比较容易改造为 policy-based，而 Q 里面严格的 max 我们不喜欢。

但是对 \(Q^{\pi_\theta}(s,a)\) 的估测也可以不使用 \(Q\) 只使用 \(V\)。于是就有如下方法：

• Critic 直接使用 \(V_\varphi(s)\) 刻画 \(V^{\pi_\theta}(s)\)。

• 对于收集到的 sample \((s_t,a_t,r_{t+1},s_{t+1},a_{t+1})\)：

  • \(Q^{\pi_\theta}(s_t,a_t)\) 可以使用 \(r_{t+1}+\gamma V_\varphi(s_{t+1})\) 估计。

    发现了什么？这就是 TD Target！

  • 于是 Actor 使用 \(\theta\gets\theta+\alpha\t{target}_\t{TD}\nabla\log\pi_\theta(s_t,a_t)\) 更新。

  • Critic 同样使用 TD Target 更新。

但是上述方法没人用。为什么呢？因为有方差更小的改进。

考虑 Dueling Network 中使用过的 Advantage 技巧。注意到对于任何只与 \(s\) 相关的 baseline \(B(s)\)，都有

\[\mat{ \E\limits_{\mat{s\sim \mu(\cdot)\\a\sim\pi_\theta(s,\cdot)}}\nabla_\theta\log\pi_\theta(s,a)\cdot B(s) \\=\E\limits_{s\sim \mu(\cdot)}\sum_a\nabla_\theta\pi_\theta(s,a)\cdot B(s)&(\text{Score Function}) \\=0&(\sum_a\pi_\theta(s,a)=1) } \]

于是我们可以取 \(B(s)\) 为 \(V^{\pi_\theta}(s)\)，然后在 Policy Gradient Theorem 的目标式中减去这个 baseline，即得

\[\E_{\mat{s\sim \mu(\cdot)\\a\sim\pi_\theta(s,\cdot)}}\nabla_\theta\log\pi_\theta(s,a)\cdot [Q^{\pi_\theta}(s,a)-V^{\pi_\theta}(s)] \\=\E_{\mat{s\sim \mu(\cdot)\\a\sim\pi_\theta(s,\cdot)}}\nabla_\theta\log\pi_\theta(s,a)\cdot A^{\pi_\theta}(s,a) \]

或者采用 trajectory 形式

\[\nabla_\theta J(\theta)\propto\E_{\tau\mid\pi_\theta}\sum_{i=0}^{T-1}\nabla_\theta\log\pi_\theta(s_i,a_i)A^{\pi_\theta}(s_i,a_i) \]

使用这个式子作为目标，就得到了 Advantage Actor-Critic (A2C)。

[!NOTE]

在 Dueling Network 中，我们使用 Advantage 是因为它可以「将 \(Q(s,a)\) 的优势外溢到其它的 \(Q(s,b)\)」。但是此处我们使用其是为了「减少方差」。具体而言，如果使用公式

\[\E_{\mat{s\sim \mu(\cdot)\\a\sim\pi_\theta(s,\cdot)}}\nabla_\theta\log\pi_\theta(s,a)\cdot(G_t-b(s)) \]

其中 \(G_t\) 是对 \(Q^{\pi_\theta}(s,a)\) 的采样，则其仍然是无偏估计——常数项对期望的影响是零。虽然它不影响 \(G_t\) 的方差，但是因为前面有一个梯度项，所以它会影响整体的方差。

理论上最优的 \(b\) 是

\[b(s)=\dfrac{\E[\|\nabla_\theta\log\pi_\theta(s,a)\|^2G_t]}{\E[\|\nabla_\theta\log\pi_\theta(s,a)\|^2]} \]

但它显然算起来太麻烦了。一个好的近似即为 \(\E[G_t]\)，也就是实际使用的 \(V^{\pi_\theta}(s)\)。

于是算法如下：

• Critic：\(V_\varphi(s)\)。

• sample：\((s_t,a_t,r_{t+1},s_{t+1},a_{t+1})\)。

• \(A^{\pi_\theta}(s_t,a_t)\approx r_{t+1}+\gamma V_\varphi(s_{t+1})-V_\varphi(s_t)\)。

  注意到这其实恰好就是我们曾经提到过的 TD error 的定义。

• 于是使用 \(\t{error}_\t{TD}=r_{t+1}+\gamma\t{SG}[V_\varphi(s_{t+1})]-V_\varphi(s_t)\)

  与 DQN 中的结论相同，这里的 target 部分需要被停止回传。

  • 更新 Actor：\(\theta\gets\theta+\alpha\t{error}_\t{TD}\nabla\log\pi_\theta(s_t,a_t)\)。
  • 更新 Critic：\(\varphi\gets\varphi-\alpha'\nabla\t{dist}(\t{error}_\t{TD})\)。

因为使用的实际上是 TD error，所以这个方法一般被称作 TD Actor-Critic。

那么 A2C 和这个 TD Actor-Critic 的区别是什么呢？前者其实是后者的现代化改进，多了一些新技巧：

• 首先因为把 TD error 解释为 Advantage，那么其就可以不那么局限，进一步结合 Multi-Step Returns 的思想，使用优化后的 \(n\)-step \(\t{error}_{n\t{-step}}=r_{t+1}+\gamma r_{t+2}+\gamma^2r_{t+3}+\dots+\gamma^n\t{SG}[V_\varphi(s_{t+n})]-V_\varphi(s_t)\) 来作为 Advantage 并更新 Actor 和 Critics。

• 更现代化的方法还包括 Generalized Advantage Estimation (GAE)

  \[\delta_t:=r_{t+1}+\gamma V(s_{t+1})-V(s_t) \\\t{error}_\t{GAE}=\sum(\gamma\lambda)^k\delta_{t+k} \]

• 在 Actor 的 loss 中增加了一个策略的熵项，鼓励探索。

• Actor 和 Critic 共享大部分网络层，减少参数量。

• 结合 Distributed RL 的思想同时从多个 agent 接受数据。

现在当我们说 TD Actor-Critic 时，一般都指的是 A2C 及其更多现代化改造了。

---

虽然 Actor-Critic 同时建模了 policy 和 value，但可以发现，其中 actor 也即 policy 才是真正的核心，value 只不过是用来辅助的技术手段而已，因此它本质上还是一种 policy based learning。

Tricks From DQN

回顾 DQN 中使用的那些技巧，看看哪些能被 A2C 使用？

• Experience Replay：不适用，因为 A2C 是 on-policy 的。当然如果硬要用的话，可以按照我们之前提过的把 on-policy 改造为 off-policy 的方法，使用 Importance Sampling 离线之。
• Freeze Target：可以用但一般不用，因为 on-policy 和并行已经保证了足够的稳定性。当然如果用了 off-policy 改造 + Experience Replay，那还是得用的。
• Double Q-Learning：不适用，我们没有维护 Q，自然不存在相关的系统性高估问题。
• 其它几个（如 Dueling Network 和 Multi-Step Returns）我们已经用上了。

Bias and Compatible Function Approximation Theorem

引入 Critic 确实可以有效减少方差，但是其本身显然是对 \(Q^{\pi_\theta}\) 或 \(A^{\pi_\theta}\) 的有偏估计，用它来训 Actor，可能就找不到正确解。

但是有如下 Compatible Function Approximation Theorem：

• 如果建模的 \(Q_\varphi(s,a)\) 满足 \(\nabla Q_\varphi(s,a)=\nabla\log\pi_\theta(s,a)\)，且训练在最小化 MSE \(\eps=\E[|Q_\varphi(s,a)-Q^{\pi_\theta}(s,a)|^2]\)，则使用该 \(Q_\varphi\) 求出的 policy gradient 是无偏的。

即，限制模型在一个奇怪的空间（\(\nabla_\varphi Q_\varphi(s,a)=\nabla_\theta\log\pi_\theta(s,a)\)）反倒可以正确刻画 policy gradient。

证明：最小化 MSE 时有梯度为零，即

\[0=\nabla_\varphi\eps=\nabla_\varphi\E[|Q_\varphi(s,a)-Q^{\pi_\theta}(s,a)|^2] \\=\E[(Q_\varphi(s,a)-Q^{\pi_\theta}(s,a))\nabla_\varphi Q_\varphi(s,a)] \\=\E[(Q_\varphi(s,a)-Q^{\pi_\theta}(s,a))\nabla_\theta\log\pi_\theta(s,a)] \]

于是即知使用 \(Q_\varphi\) 近似 \(Q^{\pi_\theta}\) 确实是无偏的。

如果要利用这个定理的话，就需要设计模型结构以保证 \(\nabla_\varphi Q_\varphi(s,a)=\nabla_\theta\log\pi_\theta(s,a)\)。这可以通过以下方式实现：

• 找一个特征提取器 \(\Phi(s,a)\)，可以使用神经网络。
• 令 \(Q_\varphi(s,a)=\varphi\cdot\Phi(s,a),\log\pi_\theta(s,a)=\theta\cdot\Phi(s,a)\)，这样约束就被完全满足了。

当然，这么做就如同 ML 中为了防止模型过拟合就主动限制其能力一样，属于早就被扫进历史垃圾堆的老想法了。现在大家都不管这个 bias，直接使用大量数据开训了。

Conclusion

我们现在终于可以回头总结 Policy Based 方法的不足之处了：

• 首先它是 on-policy 的，这就意味着数据利用效率很低（当然通过 importance sampling 可以减轻这个问题）。
• 其次因为它涉及到 actor 和 critic 的 bootstrapping 式耦合更新，一旦学习率设得不当就会陷入负循环。

因此还存在更多进阶算法！

Conclusion

Imitation Learning：因为数据不是 i.i.d. 的，遇到 o.o.d. 就会难以处理。

• Behavioural Cloning：直接嗯训。
• DAgger：引入人类专家的标注。

MDP：

• Q-Value Iteration

  \[Q_{k+1}(s,a)=\sum_{s'}T(s,a,s')[R(s,a,s')+\gamma\max_{a'}Q_k(s',a')] \]

• Value Iteration

  \[V_{k+1}(s)=\max_a\sum_{s'}T(s,a,s')[R(s,a,s')+\gamma V_k(s')] \]

• Policy Iteration：

  • Policy Evaluation

    \[V^\pi(s)=\sum_{s'}T(s,\pi(s),s')[R(s,\pi(s),s')+\gamma V^\pi(s')] \]

  • Policy Extraction

    \[\pi(s)=\arg\max_aQ(s,a) \]

    要想做 Policy Extraction 必须要 \(Q\)：这个 \(Q\) 可以是直接维护的，也可以是从 \(V\) 推出来的，后者相当于隐式确定了 \(Q\)。

• Asynchronous DP：in-place 的 Bellman 展开，不需要全局遍历。

RL：

• Adaptive DP：建模 Markov Chain 并跑 MDP。

• MCC (On Policy, Per Episode)：

  • Policy Evaluation

    \[V^\pi(s)=\E_{\tau\mid\pi}\sum\gamma^ir_i \]

  • Policy Extraction 同 MDP。

• TD (On Policy, Per Step)：

  \[V^\pi(s)\Leftarrow\t{target}_\t{TD}=R(s,\pi(s),s')+\gamma V^\pi(s') \]

• Q-Learning (Off Policy, Per Step)：
  数据是 \((s,a,r,s')\)，来源并没有明确要求。

  \[Q(s,a)\Leftarrow\t{target}_\t Q=R(s,a,s')+\gamma\max_{a'}Q(s',a') \]

• SARSA (On Policy, Per Step)：
  数据是 \((s,a,r,s',a')\)，其中 \(a,a'\) 分别是 \(s,s'\) 下的实际 action。

  \[Q(s,a)\Leftarrow\t{target}_\t{SARSA}=R(s,a,s')+\gamma Q(s',a') \]

• REINFORCE：

  • 轨迹式：
    \[\nabla_\theta J(\theta)\propto\E_{\tau\mid\pi_\theta}\sum_{i=0}^{T-1}\nabla_\theta\log\pi_\theta(s_i,a_i)\sum_{t=i+1}^Tr_t \]

• A2C：

  • 轨迹式

    \[\nabla_\theta J(\theta)\propto\E_{\tau\mid\pi_\theta}\sum_{i=0}^{T-1}\nabla_\theta\log\pi_\theta(s_i,a_i)A^{\pi_\theta}(s_i,a_i) \]

  • 状态步式：

    \[\nabla_\theta J(\theta)\propto\E_{\mat{s\sim \mu(\cdot)\\a\sim\pi_\theta(s,\cdot)}}\nabla_\theta\log\pi_\theta(s,a)\cdot A^{\pi_\theta}(s,a) \]

  • Advantage 更新：

    \[\begin{align*} A^{\pi_\theta}\approx r_{t+1}+\gamma V_\varphi(s_{t+1})-V_\varphi(s_t)&&(\t{single-step}) \\\approx \sum_{k=0}^{n-1}\gamma^k r_{t+k+1}+\gamma^nV_\varphi(s_{t+n})-V_\varphi(s_t)&&(\t{multi-step}) \\\approx\sum(\gamma\lambda)^k\delta_{t+k}&&(\t{GAE}) \\(\delta_t:=r_{t+1}+\gamma V(s_{t+1})-V(s_t)) \end{align*} \]
    \[L_\t{critic}=\t{dist}(\t{sg}(A^{\pi_\theta}+V_\varphi)-V_\varphi) \]