Skip to content

深度强化学习基础

本章节笔记主要参考了UCB CS185/285 深度强化学习课程的课件。https://rail.eecs.berkeley.edu/deeprlcourse/

强化学习复习

传统的监督学习是给定一个数据集 \(D = \{(x_i, y_i)\}\)，模型的目标是学习一个函数 \(f(x) \approx y\)。其核心假设包括：

  • i.i.d. 数据： 假设数据是独立同分布的。这意味着你今天看的一张猫的照片，不会影响明天模型看到的狗的照片。
  • Ground Truth（标准答案）： 训练时，模型知道每一个 \(x\) 对应的正确 \(y\) 是什么（比如：这张图标签就是“猫”）。

而强化学习更像是一个“闭环系统”：

  • 非 i.i.d. 数据： 这是 RL 的大坑。 之前的输出（动作）会影响未来的输入（状态） 。例如机器人把积木推倒了，它下一秒看到的画面就彻底变了。
  • 没有标准答案： 系统不会告诉你“这一步该往左移 5 厘米”，它只会在任务结束（或过程中）告诉你 成功了还是失败了 （Reward 奖励机制）。

独立同分布（Independent and Identically Distributed，i.i.d.）的含义包含两方面：

  1. 独立性（independent）：随机变量之间互不影响。模型现在看到的数据，与之前看到的数据以及之后将要看到的数据 没有任何因果或逻辑上的联系 。比如你在训练一个猫狗识别模型，第一张图是橘猫，第二张图是哈士奇。这两张图是谁、出现的顺序如何，完全互不干涉。
  2. 同分布 (Identically Distributed) ：所有的数据都来自于同一个概率分布（即遵循同样的统计规律）。训练集里的数据特征和测试集、甚至未来实际应用中的数据特征，应该是 来自同一个“大池子” 。比如说，如果你用纯白种人的头像训练人脸识别，却要在全是亚洲人的场景下使用，这就不符合同分布，模型效果会大打折扣。

RL 的核心交互框架，即 Agent（智能体）与 Environment（环境） 的循环。智能体在每个时间步 \(t\) 观察状态 \(s_t\)，输出动作 \(a_t\)。环境反馈奖励 \(r_t\) 和下一个状态 \(s_{t+1}\)。智能体必须“自己选动作”（Pick your own actions）。智能体的最终目标是学习一个策略 \(\pi_\theta : s_t \to a_t\)，使得累计奖励之和最大化：\(\sum_t r_t\)。

RL的价值在于发现新方案，他不仅仅是模仿人类。AlphaGo的神之一手彻底改变了围棋游戏规则，说明RL可以发现人类经验之外的解。Google Mind吸收Google Brain也反映了Google对逻辑路线的重视。

时至今日，强化学习早已不是机器人领域的专属method。

1770566186129

上图展示了目前大语言模型（如 ChatGPT）核心的训练机制： 基于人类反馈的强化学习（RLHF） ：

  1. 采样与生成 ：从提示词数据集（Prompts Dataset）中抽取问题，初始模型生成多个不同的回答。
  2. 人类评分（Human Scoring） ：人类对这些回答进行排序（哪个更好、更安全、更自然）。
  3. 奖励模型（Reward Model） ：利用人类的排序数据训练一个“奖励模型” \(r_{\theta}\)。这个模型学会了模拟人类的喜好。
  4. 模型进化 ：最后，利用这个奖励模型来指导原始语言模型的更新，使其输出越来越符合人类的预期。

1770566219644

上图展示了RL for image generation，其中关键组件包括LLaVA和DDPO。LLaVA是一个多模态模型，它观察生成的图片，并判断图片是否符合文字描述（例如“一只海豚在骑自行车”）。DDPO指的是扩散模型决策策略优化，它根据 LLaVA 的反馈信号来调整生成参数。

演变过程可以理解为：

  1. 最初生成的图片（左一）可能只是一只普通的海豚。
  2. 经过多次 RL 迭代，模型逐渐理解了“骑自行车”和“拟人化”的特征。
  3. 最终（右一），生成了构图准确、风格统一的“海豚骑车图”。

1770566228065

上图展示了RL在工业自动化领域的应用：芯片版图规划。其任务逻辑基于动作和奖励：

  • 动作（Actions） ：RL 代理（Agent）像玩拼图或围棋一样，一个接一个地放置宏单元（Macros）。
  • 奖励（Reward） ：放置后，系统会评估 线网总长（HPWL）和拥塞程度（Congestion） 。如果线缩短了且不拥挤，就给高分。

展现了 RL 可以在数小时内完成人类工程师需要数周才能完成的复杂芯片布局任务。

1770566634364

1770566644115

行为克隆

Behavioral Cloning (行为克隆，简称 BC) 是一种机器学习技术，旨在通过模仿人类专家的行为来训练智能体（Agent）。它是模仿学习（Imitation Learning） 中最简单且最直接的一种形式。

行为克隆将控制问题转化为了一个监督学习（Supervised Learning） 问题：

  1. 数据集是由专家（如人类驾驶员）演示的一系列“状态-动作”对 \((s, a)\)。比如专家看到摄像头画面（state）后做出了打方向盘的动作（action）。
  2. 训练目标是学习一个策略网络 \(\pi\)，使得当输入状态 \(s\) 时，输出的动作 \(\pi(s)\) 尽可能接近专家的动作 \(a\)。

行为克隆最著名的应用源于 1980 年代的 ALVINN 系统和后来的 NVIDIA 自动驾驶实验。卡内基梅隆大学（CMU）的研究员 Dean Pomerleau 开发的 ALVINN被认为是自动驾驶和行为克隆的鼻祖。当时它使用了一个极其简单的神经网络（仅有一个隐藏层），通过观察人类驾驶员在道路上的转向操作来学习。

值得注意的是，虽然强化学习（RL）的数学框架（如马尔可夫决策过程）在 20 世纪 50-80 年代就已经成熟，但它与“深度学习”的强强联手（Deep RL）要晚得多。直到2013-2016年，DeepMind发布的DQN玩Atari游戏的论文和AlphaGo才正式让深度强化学习进入大众视野。

最大似然估计

我们来看一下行为克隆的形式化定义。

假设我们有一个由专家演示的数据集 \(\mathcal{D}\)，它包含 \(N\) 条轨迹：

\[ \mathcal{D} = \{ (s_0, a_0), (s_1, a_1), \dots, (s_t, a_t) \} \]

其中：

  • \(s_t \in \mathcal{S}\)：在 \(t\) 时刻的状态（State）。
  • \(a_t \in \mathcal{A}\)：专家在状态 \(s_t\) 下做出的动作（Action）。

现在我们采用一个函数，让这个函数通过输入s来得到输出a。我们希望函数总是能按照人类的方式，换句话说，我们可以让函数来学习数据集：

\[ f_{\theta}(s) \approx a_{human} \]

如果我们采用神经网络，那么我们其实就是要找到一组参数 \(\theta\)（即神经网络的权重），来让神经网络的输出总是接近于我们的数据集\(\mathcal{D}\)。我们把这个神经网络的函数叫做策略 \(\pi_{\theta}(a|s)\)。

这里要注意，此刻我们探讨的是监督学习，而不是强化学习，因为并没有agent试错的部分。 因此我们通常在这里采用最大似然估计，即找到一组参数 \(\theta\)，使得模型预测正确标签的概率最大化。

\[ \arg \max_\theta \sum_{i=1}^N \log p_\theta(y^{(i)}|\mathbf{x}^{(i)}) \]

但是很显然，对于现实问题，我们需要引入时间序列决策。我们可以引入时间步 \(t\)，并定义变量：

  • \(\mathbf{s}_t\)：状态（State），环境的真实物理状态。
  • \(\mathbf{o}_t\)：观测（Observation），智能体（Agent）看到的图像或传感器数据。
  • \(\mathbf{a}_t\)：动作（Action），智能体做出的决策（如打方向盘）。
  • \(\pi_\theta(\mathbf{a}_t | \mathbf{o}_t)\)：策略（Policy），即我们需要学习的神经网络模型。

我们要注意，在模仿学习的策略学习中，我们通常不需要知道环境的动力学模型（即 \(p(\mathbf{s}_{t+1}|\mathbf{s}_t, \mathbf{a}_t)\)）或观测模型（\(p(\mathbf{o}_t|\mathbf{s}_t)\)），我们只关注学习策略 \(\pi_\theta\)。我们同样要关注两种情况：

  1. 部分观测（Partially Observed）： 智能体只能看到观测值 \(\mathbf{o}_t\)（比如摄像头画面），它是真实状态 \(\mathbf{s}_t\) 的一部分或变形。
  2. 完全观测（Fully Observed）： 假设观测值等于真实状态，即 \(\mathbf{o}_t = \mathbf{s}_t\)。

以上就是序列决策过程(Sequential Decision Making)。

我们将监督学习直接应用于序列决策任务，即得到了行为克隆(Behavioral Cloning)的一般方法。在行为克隆中，数据不再是单一的 \((x, y)\) 对，而是 专家演示的轨迹（Demonstration Trajectory） ：

  • 数据集包含了 \(N\) 条轨迹，每条轨迹包含 \(H\) 个时间步。
  • 数据形式为：\(\{(\mathbf{o}_t^{(i)}, \mathbf{a}_t^{(i)})\}\)，即“在看到某个画面 \(\mathbf{o}\) 时，专家做了动作 \(\mathbf{a}\)”。

其学习过程如下：

  • 输入： 当前的观测 \(\mathbf{o}_t\)（例如行车记录仪图像）。
  • 输出： 预测的动作 \(\mathbf{a}_t\)（例如方向盘角度、油门）。
  • 目标函数： 与标准的监督学习几乎完全一样，目标是最大化专家动作在策略分布下的对数似然：
\[ \arg \max_\theta \sum_{i=1}^N \sum_{t=1}^H \log \pi_\theta(\mathbf{a}_t^{(i)}|\mathbf{o}_t^{(i)}) \]

就像教学生做题一样，神经网络（学生）通过观察大量人类司机（老师）的“看到路况 -> 做出操作”的样本，单纯地模仿老师在特定情况下的反应。

损失函数

上面我们已经整理了行为克隆的通用指导思想，即利用最大似然估计的原理来让专家动作出现的概率最大。

接下来我们来看一下如何具体实现这一思想。我们可以根据不同的动作选择，来选择合适的损失函数。

对于离散动作，我们用softmax把分数变成概率。

\[ p(a_t=k | o_t) = \frac{\exp(f_k(o_t))}{\sum_j \exp(f_j(o_t))} \]

损失函数一般采用交叉熵损失。

对于连续动作，通常输出高斯分布的参数——均值 \(\mu(o_t)\) 和协方差 \(\Sigma(o_t)\)。

\[ p(a_t | o_t) = \mathcal{N}(a_t | \mu(o_t), \Sigma(o_t)) \]

如果假设方差 \(\Sigma\) 为常数矩阵 \(\mathbf{I}\)，则最大化对数似然等价于 最小化均方误差 (MSE) ：

\[ \text{Loss} \propto ||\mathbf{a}_t - \mu(\mathbf{o}_t)||^2 \]

即让神经网络输出的“动作均值”尽可能接近“专家的真实动作”。

这里的原理是，如果假设误差服从高斯分布，那么最大化概率在数学上等价于最小化两个数字的距离的平方：

\[ \text{Maximize Probability} \iff \text{Minimize } ||\text{预测值} - \text{真实值}||^2 \]

。

总结一下，上面的两种情况的通用公式即是\(\arg \max \log \pi\)，在工程落地时，我们根据output的类型选择合适的loss function：

  • 对于分类任务，比如AlphaGo落子，我们选择交叉熵损失
  • 对于回归任务，比如自动驾驶转角，我们选择MSELoss

分布偏移

上面的数学原理已经说明，简单的行为克隆往往会导致策略（Policy）产生的轨迹偏离专家轨迹。行为克隆不能保证总是有效。它与传统的监督学习（Supervised Learning）有本质区别。

行为克隆失效的核心原因是分布偏移 (Distributional Shift)。

监督学习的核心假设是训练数据和测试数据是独立同分布（i.i.d.） 的。即 \(p_{train}(x) \approx p_{test}(x)\)。然而，这一假设在BC中并不成立。

我们来看一下BC的误差累计过程：

  1. 我们在专家的状态分布 \(p_{data}(o_t)\) 下训练模型。
  2. 在测试时，模型不可避免地会产生微小的误差 \(\epsilon\)。
  3. 这个微小的误差会导致智能体进入一个稍微偏离专家轨迹的新状态。
  4. 因为这个新状态在训练数据中没有出现过（或者出现概率很低），模型的行为变得不可预测，导致产生更大的误差。
  5. 最终，状态分布 \(p_{\pi_\theta}\) 与训练分布 \(p_{data}\) 彻底偏离，导致系统崩溃（如车开出路面）。

如果我们设定：

  • \(H\)：轨迹的长度（Horizon）。
  • \(\epsilon\)：模型在训练分布上犯错的概率（即 \(\mathbb{E}_{s \sim p_{train}} [\pi_\theta(a \neq \pi^*(s))] \le \epsilon\)）。
  • 目标：估算在测试过程中，总共会犯多少次错误。

通过数学推导，我们可以得到最坏情况的结果，其误差上界是 \(O(\epsilon H^2)\) 。这里略过具体推导过程，我们主要用来对比监督学习的误差：传统的监督学习误差通常是线性的 \(O(\epsilon H)\)。随着时间 \(H\) 的增加，行为克隆的二次方级的误差会让表现迅速恶化。

尽管理论上的最坏情况界限 \(O(\epsilon H^2)\) 很悲观，但在现实中（如 NVIDIA 的车），BC 经常能用。这有可能是因为数据中包含“偏离后修正回中心”的片段，而不是完美的专家演示，因此模型能学会在分布偏移时如何自我纠正。

我们也可以通过DAgger (Dataset Aggregation) 这样的算法。它通过不断收集智能体跑偏后的数据，并请专家标注正确的动作，强行把“偏离后的状态”加入训练集，从而修正分布偏移。

总结一下分布偏移和误差累积常见的解决方法：

  1. 在数据集上进行错误动作标注，或者收集跑偏后的数据进行标注
  2. 使用更强大的模型，尽量把 \(\epsilon\)（训练误差）降到极低。如果 \(\epsilon\) 非常小，即使是 \(H^2\) 也可以接受。
  3. 在数据中人为加入噪声（扰动），强迫模型学习如何从偏离中恢复
  4. 使用多任务学习，提高模型的泛化能力

模仿学习

上面我们介绍了行为克隆，行为克隆是模仿学习（Imitation Learning, IL） 中最基础、最直观的一种形式。行为克隆的本质是监督学习，而模仿学习则是一个更大的范畴，其本质和行为克隆一样，旨在让智能体通过观察专家演示来学习策略。

除了我们上面介绍的最初的行为克隆外，模仿学习今日已经发展出了不同的流派和方向，比如：

  1. 时序模仿学习，加入非马尔科夫决策，即考虑时序，用RNN、Transformer等架构
  2. 交互式模仿学习，DAgger就属于这一类
  3. 逆向强化学习
  4. 生成对抗模仿学习
  5. Flow Matching

MDP

我们在上面讨论了强化学习早期发展中非常重要的模仿学习（Imitation Learning）和行为克隆（Behavioral Cloning）。其核心逻辑像是教小孩开车，我们给 AI 展示大量人类驾驶的视频和操作记录。AI 的目标是学习一个策略 \(\pi_\theta(a_t | s_t)\)，即在看到当前路况（状态 \(s_t\)）时，尽可能输出和人类一样的手法（动作 \(a_t\)，如打方向盘、踩油门）：

\[ \arg \max_\theta \sum_{i=1}^N \sum_{t=1}^H \log \pi_\theta(a_t^{(i)} | s_t^{(i)}) \]

这本质上是一个监督学习问题。通过最大化似然函数，让模型参数 \(\theta\) 能够预测出专家在特定状态下采取的动作。然而，如果没有好的演示数据怎么办？如果AI犯了一点小错误导致偏离了专家路径又怎么办？这便引出了对强化学习的需求。

Markov Chain

在进入复杂的强化学习之前，必须理解最简单的概率模型—— 马尔可夫链（Markov Chain） 。

我们来定义一个不考虑“动作”，只考虑“状态演变”的系统。该系统遵循马尔可夫性质（Markov Property）：

\[ s_{t+1} \perp s_{t-1} | s_t \]

其核心思想是：未来只取决于现在，而与过去无关。一旦知道了现在的状态 \(s_t\)，过去的路径对于预测 \(s_{t+1}\) 就没有额外帮助了。

1773342118665

我们用 \(p(s_{t+1} | s_t)\) 表示从一个状态转移到下一个状态的概率。如果你把所有状态的概率分布写成一个向量 \(\mu_t\)，那么下一时刻的分布可以通过矩阵乘法得到：\(\mu_{t+1} = \mathcal{T} \mu_t\)。

MDP

我们给马尔可夫链加上动作（Actions）和奖励（Rewards） ，它就变成了 MDP 。这是强化学习的标准定义。

其核心组件包括：

  1. 状态 \(s_t\)**** ：路况。
  2. 动作 \(a_t\)**** ：加速或转向。
  3. 奖励函数 \(r(s_t, a_t)\)**** ：这是最关键的改进。系统不再盲目模仿人类，而是通过“奖励信号”来判断好坏。
    • 高奖励 ：安全平稳驾驶（图中的跑车）。
    • 低奖励/负奖励 ：发生碰撞（图中的车祸）。
  4. 转移概率 \(p(s_{t+1} | s_t, a_t)\)* ：在状态 *\(s_t\) 下采取动作 \(a_t\) 后，环境会以多大几率变成 \(s_{t+1}\)。

1773342299367

如上图所示，即一个非常标准的MDP：

  1. \(\mathcal{S}\) (States) ：状态空间，环境可能处在的所有情况。
  2. \(\mathcal{A}\) (Actions) ：动作空间，智能体可以采取的所有操作。
  3. \(\mathcal{T}\) (Transition Operator) ：转移算子，即 \(p(\mathbf{s}_{t+1} | \mathbf{s}_t, \mathbf{a}_t)\)。它描述了在当前状态执行某个动作后，环境进入下一个状态的概率。
  4. \(r\) (Reward Function) ：奖励函数 \(r: \mathcal{S} \times \mathcal{A} \to \mathbb{R}\)。它告诉智能体，在状态 \(\mathbf{s}\) 采取动作 \(\mathbf{a}\) 能拿到多少即时分数。

马尔可夫链（只有状态转移，没有动作）的数学性质非常优美且易于处理。那么，当我们引入了“动作”和“策略”后，还能利用那些优美的数学工具吗？答案是肯定的，我们可以固定策略pi，然后将状态-动作对（s,a）看作一个新的大状态，那么：

1773342403569

上面这个公式：

\[ p((\mathbf{s}_{t+1}, \mathbf{a}_{t+1}) | (\mathbf{s}_t, \mathbf{a}_t)) = p(\mathbf{s}_{t+1} | \mathbf{s}_t, \mathbf{a}_t) \pi_\theta(\mathbf{a}_{t+1} | \mathbf{s}_{t+1}) \]

可以拆解为两步：

  1. 环境的一步 ：\(p(\mathbf{s}_{t+1} | \mathbf{s}_t, \mathbf{a}_t)\) —— 给定当前状态和动作，环境决定下一个状态是什么。
  2. 智能体的一步 ：\(\pi_\theta(\mathbf{a}_{t+1} | \mathbf{s}_{t+1})\) —— 看到新状态后，策略 \(\pi\) 决定下一个动作是什么。

这样做在数学上有两个巨大的好处：

  • 简化模型 ：一旦你选定了一个策略 \(\pi\)，整个 MDP 就坍缩成了一个马尔可夫链。
  • 分析长期行为 ：我们可以利用马尔可夫链的性质（比如平稳分布）来分析：如果机器人按照这个策略跑很久，它最终会频繁出现在哪些状态？这对于计算“期望回报”至关重要。

POMDP

在上面讲到的MDP中，智能体可以直接看到状态\(s_t\)。然而，在现实问题中，我们通常不具备上帝视角，我们只能通过观测来猜测状态。于是我们引入部分观测马尔可夫决策过程 (Partially Observed Markov Decision Process, POMDP)。

我们新增两个内容：

  • 新增变量 \(\mathcal{O}\) (Observations) ：智能体实际接收到的传感器数据（比如摄像头画面、雷达信号）。
  • 新增算子 \(\mathcal{E}\) (Emission Operator) ：发射算子，概率表达为 \(p(\mathbf{o}_t | \mathbf{s}_t)\)。它描述了在当前真实状态下，有多大概率产生某种观测。

例如，真实状态 \(\mathbf{s}_t\) 是你身后有一辆车，但你的后视镜有盲区，所以你的观测 \(\mathbf{o}_t\) 里没看到它。

1773342669909

如上图所示，我们可以看到图中的连线：

  1. \(\mathbf{s}_1 \to \mathbf{o}_1\) ：真实状态决定了你看到什么。
  2. \(\mathbf{s}_1, \mathbf{a}_1 \to \mathbf{s}_2\) ：真实的物理世界根据当前状态和你的动作发生演变，产生下一个真实状态 \(\mathbf{s}_2\)。
  3. \(\mathbf{s}_2 \to \mathbf{o}_2\) ：以此类推，你又得到了新的观测。

这里的关键点在于：动作 \(\mathbf{a}_t\) 现在是基于观测 \(\mathbf{o}_t\)（或者过去所有观测的历史）来做出的，而不是基于隐藏的 \(\mathbf{s}_t\)。

POMDP比较复杂（属于PSPACE完全问题），我们暂且假设传感器（如摄像头、LiDAR等）已经足够完整，可以代表当前的状态，即假设我们处于完全观测的情况。

轨迹分布

下图展示了智能体（Agent）与环境（Environment/Earth）的交互循环，并给出了轨迹的联合概率公式：1773342928398

轨迹\(\tau\)(Trajectory)指一个完整的序列：状态、动作、状态、动作…… \(\tau = (\mathbf{s}_1, \mathbf{a}_1, \dots, \mathbf{s}_H, \mathbf{a}_H)\)。

交互循环：

  • 策略 \(\pi_\theta(\mathbf{a}|\mathbf{s})\)* ：由神经网络表示，输入当前状态 *\(\mathbf{s}\)，输出动作 \(\mathbf{a}\)。
  • 环境 \(p(\mathbf{s}'|\mathbf{s}, \mathbf{a})\)* ：地球图标代表环境，它根据当前状态和你的动作，决定下一个状态 *\(\mathbf{s}'\) 是什么（这里的 \(\mathbf{s}'\) 是 \(\mathbf{s}_{t+1}\) 的简写）。

进而得到轨迹分布 \(p_\theta(\tau)\)**：

\[ p_\theta(\mathbf{s}_1, \mathbf{a}_1, \dots, \mathbf{s}_H, \mathbf{a}_H) = p(\mathbf{s}_1) \prod_{t=1}^H \pi_\theta(\mathbf{a}_t|\mathbf{s}_t) p(\mathbf{s}_{t+1}|\mathbf{s}_t, \mathbf{a}_t) \]

这个公式本质上是概率论中的 链式法则 ：

  1. \(p(\mathbf{s}_1)\)：你出生在哪（初始状态概率）。
  2. \(\pi_\theta(\mathbf{a}_t|\mathbf{s}_t)\)：在每个时刻，你根据策略选了什么动作。
  3. \(p(\mathbf{s}_{t+1}|\mathbf{s}_t, \mathbf{a}_t)\)：环境根据你的动作把你推到了下一个状态。

图中的黄色问题（where did this come from）来自 马尔可夫性质 。因为未来只取决于当前状态和动作，所以我们可以把整个序列的概率写成这些项的乘积。

这个公式和概念非常实用，可以先留个印象。

状态边际分布

如果我们不关心整个“生命轨迹”，只关心“在时间 \(t\)，我出现在状态 \(\mathbf{s}_t\) 的概率是多少”，该怎么办？换句话说，如果你按照某个策略 \(\pi_\theta\) 去跑，在某个特定时间点 \(t\)，你出现在某个特定位置 \(\mathbf{s}_t\) 的概率是多少？

\[ p_\theta(\mathbf{s}_t) = \sum_{\mathbf{a}_{1:H}, \mathbf{s}_{1:t-1}, \mathbf{s}_{t+1:H}} p_\theta(\mathbf{s}_1, \mathbf{a}_1, \dots, \mathbf{s}_H, \mathbf{a}_H) \]
\[ = \sum_{\mathbf{a}_{1:t-1}, \mathbf{s}_{1:t-1}} p(\mathbf{s}_1) \prod_{t'=1}^{t-1} \pi_\theta(\mathbf{a}_{t'}|\mathbf{s}_{t'}) p(\mathbf{s}_{t'+1}|\mathbf{s}_{t'}, \mathbf{a}_{t'}) \]

如果我们只想从这个边际分布里采样，该怎么办？如果你试图用上面那个复杂的求和公式去算，计算量是天文数字，根本算不出来。但在现实（或者代码）中，这太简单了：

  1. 让你的 AI 拿着当前的策略 \(\pi_\theta\) 去环境里 真实地跑一遍 。
  2. 跑到第 \(t\) 步时，停下来，记录下它现在的状态 \(\mathbf{s}_t\)。
  3. 这个记录下来的 \(\mathbf{s}_t\)，就是从这个边际分布里抽出的一个 样本 。

如果你跑 1000 次，这 1000 个位置的分布图，就是这个复杂的数学公式所代表的形状。

这个公式和概念非常实用，可以先留个印象。

目标函数

轨迹视角

RL的标准目标函数是：

\[ \theta^\star = \arg \max_\theta \mathbb{E}_{\tau \sim p_\theta(\tau)} \left[ \sum_t r(\mathbf{s}_t, \mathbf{a}_t) \right] \]

即我们要找到一组最优的参数 \(\theta^\star\)（通常是神经网络的权重），使得整个轨迹（Trajectory, \(\tau\)）上的累积奖励总和的期望值最大。

\(r(\mathbf{s}_t, \mathbf{a}_t)\) 表示在状态 \(\mathbf{s}_t\) 下采取动作 \(\mathbf{a}_t\) 所获得的奖励。它告诉智能体哪些状态和动作是好的。我们必须优化长期奖励（Long-term reward），比方说，如果我们给自动驾驶汽车训练策略，如果只看当下的即时奖励，那么智能体将无法避免未来可能的连锁反应（比如车祸）。

为了计算上面的期望值，需要理解一个“过程”（轨迹）是如何发生的：

\[ p_\theta(\mathbf{s}_1, \mathbf{a}_1, \dots, \mathbf{s}_H, \mathbf{a}_H) = p(\mathbf{s}_1) \prod_{t=1}^H \pi_\theta(\mathbf{a}_t|\mathbf{s}_t) p(\mathbf{s}_{t+1}|\mathbf{s}_t, \mathbf{a}_t) \]

这个公式描述了轨迹的生成逻辑：

  1. \(p(\mathbf{s}_1)\) ：初始状态。
  2. \(\pi_\theta(\mathbf{a}_t|\mathbf{s}_t)\) ： 策略（Policy） 。在状态 \(s\) 下，智能体根据参数 \(\theta\) 决定采取动作 \(a\) 的概率。
  3. \(p(\mathbf{s}_{t+1}|\mathbf{s}_t, \mathbf{a}_t)\) ： 环境状态转移 。采取动作后，环境如何变成下一个状态。

强化学习不仅仅是学习当下的正确动作，而是通过优化策略参数 \(\theta\)，使得在考虑环境互动的不确定性下，智能体在未来一段长的时间内能够获得尽可能多的总奖励。

边缘分布视角

在上面我们讨论了轨迹视角的目标函数：

\[ J(\theta) = \mathbb{E}_{\tau \sim p_\theta(\tau)} \left[ \sum_{t=1}^H r(\mathbf{s}_t, \mathbf{a}_t) \right] \]

这是我们最容易理解的强化学习目标。智能体在环境中从头走到尾，形成了一串完整的经历，这就是 轨迹（Trajectory, \(\tau\)） 。我们要找到一个最佳策略 \(\theta\)，使得在这个策略下跑出来的所有可能轨迹中，拿到的“总奖励的期望值”最大。要算这个期望，你需要知道整条轨迹 \(\tau\) 发生的概率（也就是你之前写的那一长串连乘公式）。如果只跑几个时间步 \(H\) 还能算；但如果环境是无限运行下去的（\(H \to \infty\)），这个长达无限的概率连乘在数学上根本没法处理，公式直接就“死”在这里了。

与其问“这条完整轨迹发生的概率是多少”，不如问“在第 \(t\) 个时刻，我恰好处于状态 \(\mathbf{s}_t\) 并且做了动作 \(\mathbf{a}_t\) 的概率是多少？”。我们把每个独立时刻的奖励期望算出来，然后再把所有时刻加起来。

\[ \sum_{t=1}^H \mathbb{E}_{\mathbf{s}_t, \mathbf{a}_t \sim p_\theta(\mathbf{s}_t, \mathbf{a}_t)} [r(\mathbf{s}_t, \mathbf{a}_t)] \]

我们避开了求整条轨迹的连乘，但 \(p_\theta(\mathbf{s}_t, \mathbf{a}_t)\)（即在第 \(t\) 步处于特定状态和动作的概率）写开来依然很复杂，包含了一堆求和符号。我们需要更简洁的数学工具来表达它。

矩阵视角

为了让公式看起来清爽，并且能用计算机或现成的数学定理来推导，我们引入了线性代数。我们把所有可能的状态和动作排列组合，列成一个长长的向量：

  • 把 \(p_\theta(\mathbf{s}_t, \mathbf{a}_t)\) 定义为列向量 \(\mu_t\)（第 \(t\) 步的概率分布）。
  • 把每个状态-动作对应的奖励定义为列向量 \(\vec{r}\)。
  • 把从上一步转移到下一步的概率，定义为一个巨大的转移矩阵 \(\mathcal{T}_\theta\)。

时间步的推进变成了极简的矩阵乘法：

\[ \mu_{t+1} = \mathcal{T}_\theta \mu_t \]

而原本复杂的总目标函数，变成了一系列向量点积的求和：

\[ \sum_{t=1}^H \mu_t^T \vec{r} \]

在马尔可夫链的理论中，如果一个转移矩阵 \(\mathcal{T}_\theta\) 不断地乘下去（时间推移），这个概率分布向量 \(\mu_t\) 最终会停止变化，稳定在一个固定的分布上。这个最终稳定的向量被称为 平稳分布（Stationary Distribution, \(\bar{\mu}\)） 。

既然分布不变了，那么乘以转移矩阵后还是它自己：

\[ \bar{\mu} = \mathcal{T}_\theta \bar{\mu} \implies (\mathcal{T}_\theta - \mathbf{I})\bar{\mu} = 0 \]

此时，我们在无限长的时间里，平均每一步能拿到的奖励期望，被极其优雅地浓缩成了最终的平稳分布向量与奖励向量的点积：

\[ J(\theta) = \bar{\mu}^T \vec{r} \]

这个最终简化出来的\(\bar{\mu}^T \vec{r}\)是强化学习在面临 无限时间（Infinite Horizon）时，目标函数的终极化简形态 。它代表的是：在长期运行中，智能体平均每步能获得的期望奖励。

蒙特卡洛估计

上面我们讨论了复杂的数学理论，在实际应用中，我们一般会进行采样，并把取得的轨迹叫做rollout。我们会在rollout中随机取batch来训练策略网络。

在工程实践中，我们可以把这种方式写为：

\[ \mathbb{E}_{\tau \sim p_\theta(\tau)} \left[ \sum_{t=1}^H r(\mathbf{s}_t, \mathbf{a}_t) \right] \approx \frac{1}{N} \sum_{i=1}^N \left( \sum_{t=1}^H r(\mathbf{s}_t^{(i)}, \mathbf{a}_t^{(i)}) \right) \]

其中左半边指的就是理论上的 期望（Expectation） 。也就是前面那些幻灯片费尽心机用马尔可夫链、转移矩阵、平稳分布 \(\bar{\mu}\) 想要计算的绝对真理。在代码中，我们永远算不出这个值，因为环境的可能性是无限的，我们不可能穷举出所有的情况。

右半边是工程实现的一般方法，即算出batch均值：

\[ \frac{1}{N} \sum_{i=1}^N (\text{第 } i \text{ 条 rollout 的总奖励}) \]

这背后隐含的数学原理是大数定律：不要去管什么平稳分布、什么无穷大矩阵转移概率。只要你的策略模型（神经网络）在这个环境里跑的次数（\(N\)）足够多，你随机抽一个 Batch 算出来的平均分，就无限等于那个高深莫测的理论期望值。

期望

我们为什么要费这么大劲去求“期望（Expectations）”，而不是直接去最大化“奖励（Reward）”本身？

在强化学习中，只有引入了“期望”和“随机性（Stochastic）”，我们才能把一个不可导的现实世界，变成一个神经网络可以求导（求梯度）的数学模型。

Infinite horizon case，无限视界：

\[ \theta^\star = \arg\max_\theta \mathbb{E}_{(\mathbf{s, a}) \sim p_\theta(\mathbf{s, a})}[r(\mathbf{s, a})] \]

这就是 \(\bar{\mu}^T \vec{r}\) 的另一种写法，这里的 \(p_\theta(\mathbf{s, a})\) 就是系统在无限时间下稳定后的状态-动作概率（也就是 \(\bar{\mu}\)）。

Finite horizon case，有限视界：

\[ \theta^\star = \arg\max_\theta \sum_{t=1}^T \mathbb{E}_{(\mathbf{s}_t, \mathbf{a}_t) \sim p_\theta(\mathbf{s}_t, \mathbf{a}_t)}[r(\mathbf{s}_t, \mathbf{a}_t)] \]

这就是蒙特卡洛估计等号左边的内容（只是把原本的一整条轨迹的期望，拆成了每一步期望的和，也就是我们说的“桥梁——边缘分布视角”）。

在强化学习中，我们几乎总是关注期望。

以下图为例：

1773350547544

假设我们在训练自动驾驶汽车：

  • 安全在路上 ：奖励 +1
  • 掉下悬崖 ：奖励 -1

我们知道，现实世界的奖励往往是不平滑（not smooth）的。比方说，汽车往右偏 10 厘米，可能还在路上（奖励 +1）；再往右偏 1 厘米，掉下去了（奖励突变成 -1）。这种类似“阶跃”的突变函数是 不可导的 。如果不可导，你的神经网络（依赖反向传播和梯度下降）就彻底瞎了，它不知道该怎么微调参数 \(\theta\)。

我们让策略变成概率性（Stochastic）的。假设神经网络输出一个掉下悬崖的概率 \(\pi_\theta(\mathbf{a}=\text{fall}) = \theta\)。（这里的 \(\theta\) 可以理解为 0 到 1 之间的一个参数）。

我们不再直接看单次奖励，而是看 奖励的期望值（Expectation） ：

\[ E_{\pi_\theta}[r(\mathbf{x})] = (1-\theta) \cdot (+1) + \theta \cdot (-1) = 1 - 2\theta \]

原本突变的 +1 和 -1，经过概率 \(\theta\) 加权求和后，变成了一个连续的函数（\(1 - 2\theta\)）。这个函数极其平滑，你的神经网络马上就能算出梯度（导数是 -2），从而知道“要想让期望变大，我必须减小 \(\theta\)（掉下悬崖的概率）”。

由此，我们发现，强化学习的底层逻辑链路此刻已经完整了：

  1. 我们的目标几乎总是期望，因为现实世界的奖励不平滑、不可导。求期望能把离散的突变“抹平”，让神经网络可以计算梯度。
  2. 理论期望可以写成有限步的加和，或者是无限步的平稳分布。
  3. 由于现实中理论期望算不出来，所以我们往往用蒙特卡洛采样来近似计算这个期望。

因为现实环境的奖励往往是突变且不可导的（比如掉下悬崖瞬间从 +1 变成 -1），只有通过概率计算期望，才能将其抹平为平滑连续的数学函数，从而让神经网络算得出梯度来更新参数。换句话说，没有期望的话，神经网络根本无法学习。

RL Anatomy

循环迭代框架

强化学习（Reinforcement Learning, RL）算法的核心架构（Anatomy）可以简化为一个不断循环的三个步骤。1773351178167

这三个步骤分别如下：

  1. 生成样本，也就是让agent去和环境交互，agent会根据当前policy在环境中做出动作，然后收集：状态、动作、奖励。
  2. 拟合模型/估计回报：算法会针对收集到的数据进行评估和分析，计算这些动作带来了多少收益，或者尝试学习环境的规律（也就是拟合模型）。
  3. 改进策略：根据上一步得到的评估结果，优化agent的行为准则。改进后的新策略将用于下一轮的样本生成，其目标是让智能体在未来更有可能选择那些获得更高回报的动作。

RL是一个迭代循环的过程，算法不是一次性完成的，而是通过“行动 -> 评估 -> 改进 -> 再行动”的闭环不断进化。无论是深度强化学习（Deep RL）还是传统的 RL 算法，基本都遵循这个宏观框架。

Model-Free

这里介绍一下基于策略梯度的无模型RL。这里只是介绍，来说明循环迭代框架。

“模型”（Model）在强化学习里指的是智能体对环境规律的理解。这个规律通常包含两个核心问题：

  1. 状态转移 ：如果我在状态 \(s\) 做了动作 \(a\)，下一个状态 \(s'\) 会是什么？
  2. 奖励预测 ：这个动作能给我带来多少奖励 \(r\)？

无模型方法属于经验派，它不去尝试理解环境背后的逻辑，而只关心结果。通过大量的试错，直接学习“什么状态下该做什么动作”（策略）或者“这个状态价值几何”（价值函数）。

Model-Free简单直接，不需要复杂建模，适用于环境极其复杂与难以预测的场景。其缺点也很明显：采样效率低，需要尝试成千上万次才能学到东西。我们学习RL时先学的算法如Q-Learning, SARSA, PPO, DQN等都是Model-Free的。

1773351489553

无模型的意思就是不关心环境如何运作，直接观察结果。我们直接计算样本的平均总奖励：

\[ J(\theta) = E_\pi [\sum r_t] \approx \frac{1}{N} \sum \sum r \]

公式 \(J(\theta) = E_\pi [\sum r_t]\) 表示目标是最大化期望回报，右边的 \(\frac{1}{N} \sum \sum r\) 说明它是通过对多条实验路径（Trajectories）求平均来估算这个期望的。

我们采用使用 策略梯度上升 ：\(\theta \leftarrow \theta + \alpha \nabla_\theta J(\theta)\)来改进策略。 如果一组动作导致了高奖励，就增加产生这些动作的概率；如果奖励低，就减少概率。这像是在进行“黑盒试错”。

Model-Based

有模型方法会先尝试在脑子里构建一个“环境模拟器”。智能体会尝试学习环境的规律。一旦它掌握了规律，就可以在“想象”中进行推演，而不需要每次都去真实环境里碰壁。

最常见的例子就是下围棋：棋手非常清楚游戏的规则（模型）：如果我落子在这里，棋盘会变成什么样。所以棋手可以在落子前，在脑子里进行“深思熟虑”地推演：“如果我走 A，他可能走 B，那我接着走 C...”。

有模型算法包括Dyna-Q, AlphaZero, World Models等。其采样效率高，可以在学到的模型里自我演练，减少了在真实环境中的危险和成本。其缺点是如果对环境的建模错了（Model Bias），从而导致智能体在错误的路上越走越远，最终在现实中错得离谱。

1773352516863

这种方法试图理解环境的运行规律，即学习一个“世界模型”。它通过学习一个状态转移函数 \(f_\phi\)，使得 \(s_{t+1} \approx f_\phi(s_t, a_t)\)来拟合模型。

直观理解就是说，它在用神经网络模拟现实。输入当前状态和动作，预测下一个状态。它在问：“如果我这么做，世界会变成什么样？”

接着，通过 模型和奖励函数进行反向传播 （Backprop）来改进策略。因为它现在有了一个可以求导的模型 \(f_\phi\)，它就可以直接计算“动作的微小改变如何影响未来的状态，进而影响奖励”。这比图一的“试错”更加精准，因为它利用了环境的内在逻辑。

双层循环

现代RL结合了Model-Free和Model-Based的思想，采用双层循环方法：一层与真实世界接触，另一层在“大脑”里推演。

这些方法都算是比较新的方法，具体的实现方法和思路等后面再补充。

成本评估

在RL Anatomy中，每个部分的成本如下：

  1. 生成样本的时间成本较高。如果是在真实的机器人、自动驾驶汽车或电网中运行，受限于物理法则，它只能以“1倍速”运行。这意味着收集 1 小时的数据就得实打实花 1 小时。这在科研和工业应用中是极大的时间成本。如果有高性能模拟器，速度可以提升到现实世界的 10000 倍，大大缓解这一成本。
  2. 拟合模型/估计回报的计算成本较高。
  3. 改进策略的成本相较于上面两者，通常不算是瓶颈。

我们可以发现，强化学习的瓶颈主要在于：

  1. 数据获取的时间成本
  2. 模型训练的计算成本

价值评估与策略改进

Q-function

Q-function（Q函数） ，全称是 State-Action Value Function（状态-动作价值函数），通常用 \(Q(s, a)\) 表示。它的核心作用是 评估在特定状态下采取某个动作到底有多好 。具体来说，当你处于状态 \(s\)，选择了动作 \(a\)，并且之后都遵循某种特定的策略（Policy）行动时，\(Q(s, a)\) 代表了你从现在开始直到结束，所能获得的 期望累积总奖励 。

我们知道，强化学习的原始目标是：

\[ E_{\tau \sim p_\theta(\tau)} \left[ \sum_{t=1}^H r(\mathbf{s}_t, \mathbf{a}_t) \right] \]

它表示在策略 \(\theta\) 下生成一条长度为 \(H\) 的轨迹 \(\tau\)，我们希望最大化这条轨迹上所有单步奖励 \(r\) 的总和的期望。这是一个针对整条时间线的全局宏观目标，直接优化它非常困难。

长轨迹其实可以拆成两部分：第一步的收益 + 未来所有步的收益 。

\[ Q(\mathbf{s}_1, \mathbf{a}_1) = r(\mathbf{s}_1, \mathbf{a}_1) + E_{\mathbf{s}_2 \sim p} \left[ E_{\mathbf{a}_2 \sim \pi} [r(\mathbf{s}_2, \mathbf{a}_2) + ... | \mathbf{s}_2] | \mathbf{s}_1, \mathbf{a}_1 \right] \]

这里正式定义了 Q 函数。它假设：“如果我们已经知道了未来这部分的期望收益（大括号框起来的部分）会怎样？”。这样，Q 函数就把从第2步到第 \(H\) 步的复杂未来，压缩成了一个已知的值。

\[ E_{\tau \sim p_\theta(\tau)} \left[ \sum_{t=1}^H r(\mathbf{s}_t, \mathbf{a}_t) \right] = E_{\mathbf{s}_1 \sim p(\mathbf{s}_1)} \left[ E_{\mathbf{a}_1 \sim \pi(\mathbf{a}_1|\mathbf{s}_1)} [Q(\mathbf{s}_1, \mathbf{a}_1)|\mathbf{s}_1] \right] \]

通过代入 Q 函数，原本需要考虑整条长轨迹 \(\tau\) 的庞大目标（左边），被等价替换成了只需考虑第一步的状态和动作的极简目标（右边）。所有的“未来预测”都被打包进 \(Q(\mathbf{s}_1, \mathbf{a}_1)\) 里了。

如果我们真的知道了完美的 Q 函数，那么改进策略（Policy Improvement） 就会变得像喝水一样简单。我们完全不需要往后推演几百步，只需要看眼前哪一个动作 \(\mathbf{a}_1\) 对应的 Q 值最大（即 \(\arg\max\)），我们就在这一步百分之百（概率为 1）选择这个动作就好了（这就是贪心策略）。

这里给出更严谨的定义：

\[ Q^\pi(\mathbf{s}_t, \mathbf{a}_t) = \sum_{t'=t}^T E_{\pi_\theta}[r(\mathbf{s}_{t'}, \mathbf{a}_{t'}) | \mathbf{s}_t, \mathbf{a}_t] \]

在状态 \(\mathbf{s}_t\) 下，你强制采取特定的动作 \(\mathbf{a}_t\)，并且在此之后一直遵循策略 \(\pi_\theta\) 行动，直到时间 \(T\) 结束，你所能获得的“总奖励的期望值”。

象棋比喻 ：棋盘现在的局面是 \(\mathbf{s}_t\)。Q函数评估的是： “如果我这一步把马跳到 f3 位置（动作 \(\mathbf{a}_t\)）” ，接下来按我的正常水平下完这盘棋，我赢的概率或者得分是多少。它具体到了某一个动作的好坏。

Value Function

Value function (状态价值函数)通常用 \(V\) 表示：

\[ V^\pi(\mathbf{s}_t) = \sum_{t'=t}^T E_{\pi_\theta}[r(\mathbf{s}_{t'}, \mathbf{a}_{t'}) | \mathbf{s}_t] \]

处于状态 \(\mathbf{s}_t\) 时，如果你从现在开始一直遵循策略 \(\pi_\theta\) 行动，直到结束，你所能获得的“总奖励的期望值”。注意，这里 没有强制规定第一步必须走哪个动作 ，而是完全按照你的策略 \(\pi_\theta\) 去随机或确定地选择。

象棋比喻 ：棋盘现在的局面是 \(\mathbf{s}_t\)。V函数评估的是： “目前这个局势对我到底是有利还是有弊？” （比如常见的“白方占优 +2.0”）。它只评价状态本身的好坏，不涉及具体走哪步棋。

状态的价值（\(V\)），就等于在这个状态下所有可能采取的动作的价值（\(Q\)）的 加权平均 。权重的分配，就是你的策略 \(\pi\) 选择某个动作的概率。

\[ V^\pi(\mathbf{s}_t) = E_{\mathbf{a}_t \sim \pi(\mathbf{a}_t|\mathbf{s}_t)}[Q^\pi(\mathbf{s}_t, \mathbf{a}_t)] \]

换句话说，一个局势好不好，取决于你能在这个局势下走出的各种招数有多好，以及你有多大的概率会选择那些好招数。

RL的两个核心公式

从上面我们不难推断，强化学习的终极目标就是在追求 最大化初始状态 \(\mathbf{s}_1\) 的期望价值，也就是：

\[ E_{\mathbf{s}_1 \sim p(\mathbf{s}_1)}[V^\pi(\mathbf{s}_1)] \text{ is the RL objective!} \]

那么在我们计算出 Q 函数和 V 函数之后，到底该怎么 利用它们来让 AI 变得更聪明（改进策略） 呢？

一般有两种主流思路：

  1. 贪心策略改进，也就是基于价值的方法
  2. 提高好动作的概率，也就是基于策略梯度的方法

对于第一种思路，即贪心策略改进 (Policy Improvement)，或者说“基于价值”的方法（如 Q-learning, DQN），如果我们有一个旧策略 \(\pi\)，并且我们算出了它对应的 \(Q^\pi(\mathbf{s}, \mathbf{a})\)，我们就能轻松得到一个更好的新策略 \(\pi'\)。方法很简单：在状态 \(\mathbf{s}\) 下，哪个动作 \(\mathbf{a}\) 的 Q 值最高（即 \(\arg\max_{\mathbf{a}} Q^\pi(\mathbf{s}, \mathbf{a})\)），我们就把采取该动作的概率设为 1（也就是百分之百选它）。这是一种“简单粗暴但有效”的改进方式。既然 Q 函数已经告诉你每个动作未来能拿多少分，那你就别犹豫了， 每次都无脑选那个得分最高的动作就行了 。数学上可以证明，这样构造出的新策略 \(\pi'\)，至少和旧策略 \(\pi\) 一样好，而且通常会更好（this policy is at least as good as \(\pi\) (and probably better)!）。这就形成了一个闭环：评估策略 -> 选最大Q值改进策略 -> 重新评估 -> 再次改进，直到策略完美。

该思路的核心策略更新公式是：

\[ \pi'(\mathbf{a}|\mathbf{s}) = 1 \quad \text{if} \quad \mathbf{a} = \arg\max_{\mathbf{a}} Q^\pi(\mathbf{s}, \mathbf{a}) \]

在新策略 \(\pi'\) 中，在状态 \(\mathbf{s}\) 下，如果动作 \(\mathbf{a}\) 能让对应的 \(Q\) 值最大化，那么我们就以 \(1\)（即 \(100\%\)）的概率去执行它，其余动作的概率全为 \(0\)。

对于第二种思路，即提高好动作的概率 (Policy Gradient)，或者说“基于策略梯度”的方法（如 REINFORCE, Actor-Critic, PPO），我们通过计算梯度来增加“好动作”被选中的概率。怎么定义动作好不好？如果 \(Q^\pi(\mathbf{s}, \mathbf{a}) > V^\pi(\mathbf{s})\)，说明动作 \(\mathbf{a}\) 比平均水平要好。因此，我们应该修改策略 \(\pi(\mathbf{a}|\mathbf{s})\)，让选这个动作的概率变大：

  • 如果某个具体动作的分数 \(Q\) 大于 均分 \(V\)，说明这个动作是一个“超常发挥”的好动作，我们要在未来的训练中鼓励 AI 多做这个动作（增加概率）。
  • 反之，如果 \(Q < V\)，说明这个动作“拖了后腿”，我们就惩罚它，降低它被选中的概率。

\(Q^\pi(\mathbf{s}, \mathbf{a}) - V^\pi(\mathbf{s})\) 这个差值，在强化学习中有一个专门的术语，叫做 优势函数 (Advantage Function) ，通常用 \(A(\mathbf{s}, \mathbf{a})\) 表示。它衡量的是“这个动作比平均水平好多少”。

该思路的核心计算公式是优势函数：

\[ A^\pi(\mathbf{s}, \mathbf{a}) = Q^\pi(\mathbf{s}, \mathbf{a}) - V^\pi(\mathbf{s}) \]

策略更新逻辑是：

  • 如果 \(A^\pi(\mathbf{s}, \mathbf{a}) > 0\) （即 \(Q^\pi > V^\pi\)）：说明动作 \(\mathbf{a}\) 是个“好动作”，在未来的策略更新中需要 增大 \(\pi(\mathbf{a}|\mathbf{s})\) 的概率。
  • 如果 \(A^\pi(\mathbf{s}, \mathbf{a}) < 0\) （即 \(Q^\pi < V^\pi\)）：说明动作 \(\mathbf{a}\) 是个“坏动作”，在未来的策略更新中需要 减小 \(\pi(\mathbf{a}|\mathbf{s})\) 的概率。

这两个核心公式在RL中非常重要，我们在之后的正式学习中会反复触达。

RL算法类型

所有的RL算法的核心目标都是最大化期望回报：

\[ \theta^\star = \arg\max_\theta E_{\tau \sim p_\theta(\tau)} \left[ \sum_t r(\mathbf{s}_t, \mathbf{a}_t) \right] \]

我们来简要看一下都有哪些主要算法类型，以及他们的主要区别。具体的算法我们在未来学习时再深入了解。

Value-based

Value-based estimate value function or Q-function of the optimal policy (no explicit policy).

1773355125136

Policy Gradients

Policy gradients directly differentiate the above objective.

1773355140820

Actor-Critic

Actor-critic estimate value function or Q-function of the current policy, use it to improve policy.1773355155558

Model-based

Model-based RL estimate the transition model, and then use it for planning (no explicit policy), use it to improve a policy, and something else.

1773355060673

improve the policy — a few options

  1. Just use the model to plan (no policy) • Trajectory optimization / optimal control (primarily in continuous spaces) – essentially backpropagation to optimize over actions • Discrete planning in discrete action spaces – e.g., Monte Carlo tree search
  2. Backpropagate gradients into the policy • Requires some tricks to make it work
  3. Use the model to learn a value function • Dynamic programming • Generate simulated experience for model-free learner

对比

之所以有这么多RL算法，是因为针对不同的任务，我们面对不同的tradeoffs以及不同的假设：

  1. Different tradeoffs: Sample Efficiency / Stability & ease of use
  2. Different assumptions: Stochastic or Deterministic? / Continuous or discrete? / Episodic or infinite horizon?
  3. Easier to represent the policy? / Easier to represent the model?

1773355397027

1773354666829

1773355413215

1773355421625

1773355432305

评论 #