MiniMind 学习笔记(十八):速通强化学习——从 MDP 到 PPO 的概念与算法地图

MiniMind 学习笔记(十八):速通强化学习------从 MDP 到 PPO 的概念与算法地图

在进入强化学习在 LLM 中的应用之前,先用一节内容串讲并总结强化学习的基础知识。这部分基本可以看作是对西湖大学赵世玉老师强化学习课程的学习整理(课程资料开源在 GitHub)。本节主要完成两件事:第一 ,把 RL 中重要且基础的概念、定义和公式梳理清楚------RL 是一个概念密度很高、符号也容易混乱的领域,先统一下记号,后面讨论具体算法时就不容易迷路;第二,梳理不同算法之间的思路演变和基本逻辑关系,建立一条主线:这些算法分别想解决什么问题,以及它们之间大致如何连接。

文章目录

[MiniMind 学习笔记(十八):速通强化学习------从 MDP 到 PPO 的概念与算法地图](#MiniMind 学习笔记(十八):速通强化学习——从 MDP 到 PPO 的概念与算法地图)
- 全章知识地图
第一部分:基本概念与问题定义
- 一、基本记号:先区分"随机变量"和"取值"
- 二、MDP:强化学习问题的数学对象
- 三、策略与轨迹
- 四、Return:定义"表现好坏"
- [五、State value:对 return 取期望](#五、State value:对 return 取期望)
- [六、Q value / Action value](#六、Q value / Action value)
[第二部分:Bellman 方程](#第二部分:Bellman 方程)
- [七、Bellman expectation equation](#七、Bellman expectation equation)
- [八、矩阵形式:policy evaluation 就是解线性方程组](#八、矩阵形式:policy evaluation 就是解线性方程组)
- [九、Bellman 最优方程与最优策略](#九、Bellman 最优方程与最优策略)
- - [9.1 解的存在性与唯一性](#9.1 解的存在性与唯一性)
[第三部分:传统算法脉络(DP → MC → TD)](#第三部分:传统算法脉络(DP → MC → TD))
- [十、Value iteration 与 Policy iteration](#十、Value iteration 与 Policy iteration)
- [十一、Monte Carlo Learning](#十一、Monte Carlo Learning)
- [十二、Temporal-Difference Learning](#十二、Temporal-Difference Learning)
- - [12.1 TD vs MC](#12.1 TD vs MC)
  - [12.2 On-policy 与 Off-policy:先区分两个策略](#12.2 On-policy 与 Off-policy:先区分两个策略)
第四部分:函数逼近
- [十三、为什么需要 value function approximation?](#十三、为什么需要 value function approximation?)
- [十四、Sarsa / Q-learning with Function Approximation](#十四、Sarsa / Q-learning with Function Approximation)
- 十五、DQN:两个关键工程技巧
[第五部分:Policy Gradient 与 Actor-Critic](#第五部分:Policy Gradient 与 Actor-Critic)
- [十六、从 value-based 到 policy-based](#十六、从 value-based 到 policy-based)
- [十七、Actor-Critic 家族](#十七、Actor-Critic 家族)
第六部分:通用工具与思想
- [十八、Monte Carlo estimation](#十八、Monte Carlo estimation)
- [十九、Robbins-Monro / Stochastic Approximation](#十九、Robbins-Monro / Stochastic Approximation)
- - [19.1 三类收敛条件](#19.1 三类收敛条件)
  - [19.2 应用一:求期望的值](#19.2 应用一:求期望的值)
  - [19.3 应用二:TD learning 是 stochastic approximation 的一个实例](#19.3 应用二:TD learning 是 stochastic approximation 的一个实例)
- [二十、SGD / BGD / MBGD 与重要性采样](#二十、SGD / BGD / MBGD 与重要性采样)
第七部分:概念总结
- 二十一、七组核心分类
- - [21.1 Model-based 与 Model-free](#21.1 Model-based 与 Model-free)
  - [21.2 On-policy 与 Off-policy](#21.2 On-policy 与 Off-policy)
  - [21.3 Online 与 Offline](#21.3 Online 与 Offline)
  - [21.4 Online/Offline 与 On-policy/Off-policy 的关系](#21.4 Online/Offline 与 On-policy/Off-policy 的关系)
  - [21.5 Behavior policy 与 Target policy](#21.5 Behavior policy 与 Target policy)
  - [21.6 Exploration 与 Exploitation](#21.6 Exploration 与 Exploitation)
  - [21.7 Episodic Task 与 Continuing Task](#21.7 Episodic Task 与 Continuing Task)
- [二十二、统一视角:从"期望"和"样本"理解 RL 算法](#二十二、统一视角:从"期望"和"样本"理解 RL 算法)
- [二十三、RL 中的样本构造:四个层次](#二十三、RL 中的样本构造:四个层次)
- [二十四、Bootstrapping 与 Non-bootstrapping](#二十四、Bootstrapping 与 Non-bootstrapping)
- [二十五、Tabular / Value-based / Policy-based 等其他分类](#二十五、Tabular / Value-based / Policy-based 等其他分类)
- 二十六、常见算法粗略分类总表
- 总结
- 参考

全章知识地图

#mermaid-svg-uVgnciMJ8CeDEzdn{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-uVgnciMJ8CeDEzdn .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-uVgnciMJ8CeDEzdn .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-uVgnciMJ8CeDEzdn .error-icon{fill:#552222;}#mermaid-svg-uVgnciMJ8CeDEzdn .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-uVgnciMJ8CeDEzdn .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-uVgnciMJ8CeDEzdn .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-uVgnciMJ8CeDEzdn .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-uVgnciMJ8CeDEzdn .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-uVgnciMJ8CeDEzdn .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-uVgnciMJ8CeDEzdn .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-uVgnciMJ8CeDEzdn .marker{fill:#333333;stroke:#333333;}#mermaid-svg-uVgnciMJ8CeDEzdn .marker.cross{stroke:#333333;}#mermaid-svg-uVgnciMJ8CeDEzdn svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-uVgnciMJ8CeDEzdn p{margin:0;}#mermaid-svg-uVgnciMJ8CeDEzdn .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-uVgnciMJ8CeDEzdn .cluster-label text{fill:#333;}#mermaid-svg-uVgnciMJ8CeDEzdn .cluster-label span{color:#333;}#mermaid-svg-uVgnciMJ8CeDEzdn .cluster-label span p{background-color:transparent;}#mermaid-svg-uVgnciMJ8CeDEzdn .label text,#mermaid-svg-uVgnciMJ8CeDEzdn span{fill:#333;color:#333;}#mermaid-svg-uVgnciMJ8CeDEzdn .node rect,#mermaid-svg-uVgnciMJ8CeDEzdn .node circle,#mermaid-svg-uVgnciMJ8CeDEzdn .node ellipse,#mermaid-svg-uVgnciMJ8CeDEzdn .node polygon,#mermaid-svg-uVgnciMJ8CeDEzdn .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-uVgnciMJ8CeDEzdn .rough-node .label text,#mermaid-svg-uVgnciMJ8CeDEzdn .node .label text,#mermaid-svg-uVgnciMJ8CeDEzdn .image-shape .label,#mermaid-svg-uVgnciMJ8CeDEzdn .icon-shape .label{text-anchor:middle;}#mermaid-svg-uVgnciMJ8CeDEzdn .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-uVgnciMJ8CeDEzdn .rough-node .label,#mermaid-svg-uVgnciMJ8CeDEzdn .node .label,#mermaid-svg-uVgnciMJ8CeDEzdn .image-shape .label,#mermaid-svg-uVgnciMJ8CeDEzdn .icon-shape .label{text-align:center;}#mermaid-svg-uVgnciMJ8CeDEzdn .node.clickable{cursor:pointer;}#mermaid-svg-uVgnciMJ8CeDEzdn .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-uVgnciMJ8CeDEzdn .arrowheadPath{fill:#333333;}#mermaid-svg-uVgnciMJ8CeDEzdn .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-uVgnciMJ8CeDEzdn .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-uVgnciMJ8CeDEzdn .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-uVgnciMJ8CeDEzdn .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-uVgnciMJ8CeDEzdn .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-uVgnciMJ8CeDEzdn .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-uVgnciMJ8CeDEzdn .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-uVgnciMJ8CeDEzdn .cluster text{fill:#333;}#mermaid-svg-uVgnciMJ8CeDEzdn .cluster span{color:#333;}#mermaid-svg-uVgnciMJ8CeDEzdn div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-uVgnciMJ8CeDEzdn .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-uVgnciMJ8CeDEzdn rect.text{fill:none;stroke-width:0;}#mermaid-svg-uVgnciMJ8CeDEzdn .icon-shape,#mermaid-svg-uVgnciMJ8CeDEzdn .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-uVgnciMJ8CeDEzdn .icon-shape p,#mermaid-svg-uVgnciMJ8CeDEzdn .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-uVgnciMJ8CeDEzdn .icon-shape .label rect,#mermaid-svg-uVgnciMJ8CeDEzdn .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-uVgnciMJ8CeDEzdn .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-uVgnciMJ8CeDEzdn .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-uVgnciMJ8CeDEzdn :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 统一解释
统一解释
RL 基础速通
① 基本概念与问题定义

记号 / MDP / 策略 / 轨迹

Return / State value / Q value
② Bellman 方程

期望形式 / 矩阵形式 / 最优方程
③ 传统算法脉络

DP → MC → TD
④ 函数逼近

FA-Sarsa / FA-Q / DQN
⑤ Policy Gradient 与 Actor-Critic
⑥ 通用工具

MC估计 / Robbins-Monro

SGD / 重要性采样
⑦ 概念总结

七组分类 + 统一视角

第一部分:基本概念与问题定义

一、基本记号:先区分"随机变量"和"取值"

RL 的问题定义里随机变量个数偏多,请时刻牢记随机变量和随机变量取值的区别,否则很多公式会变得非常混乱。

记号	含义
S t S_t St	时刻 t t t 的状态,是随机变量
A t A_t At	时刻 t t t 在状态 S t S_t St 下采取的动作,是随机变量
R t + 1 R_{t+1} Rt+1	执行动作 A t A_t At 之后得到的奖励,是随机变量
S t + 1 S_{t+1} St+1	执行动作 A t A_t At 之后转移到的下一个状态,是随机变量
s , a , r , s ′ s, a, r, s' s,a,r,s′	分别表示状态、动作、奖励、下一状态的具体取值
S \mathcal{S} S	状态空间
A ( s ) \mathcal{A}(s) A(s)	状态 s s s 下可选动作的集合
γ ∈ [ 0 , 1 ) \gamma \in [0,1) γ∈[0,1)	折扣因子,控制未来奖励在当前价值中的权重

一个单步交互写成:

S t → A t R t + 1 , S t + 1 S_t \xrightarrow{A_t} R_{t+1}, S_{t+1} StAt Rt+1,St+1

即:智能体在状态 S t S_t St 下选择动作 A t A_t At,环境返回奖励 R t + 1 R_{t+1} Rt+1,并转移到新状态 S t + 1 S_{t+1} St+1。

注意 :奖励的角标是 t + 1 t+1 t+1,而不是状态的 t t t。这个细节在推导 Bellman 方程时非常关键。

二、MDP:强化学习问题的数学对象

强化学习中最常用的建模方式是 Markov Decision Process(MDP):

M = ( S , A , p , r , γ ) \mathcal{M} = (\mathcal{S}, \mathcal{A}, p, r, \gamma) M=(S,A,p,r,γ)

环境的单步随机性用联合分布表示:

p ( s ′ , r ∣ s , a ) = Pr ⁡ ( S t + 1 = s ′ , R t + 1 = r ∣ S t = s , A t = a ) p(s', r \mid s, a) = \Pr(S_{t+1}=s', R_{t+1}=r \mid S_t=s, A_t=a) p(s′,r∣s,a)=Pr(St+1=s′,Rt+1=r∣St=s,At=a)

有时也把状态转移和奖励分开写 p ( s ′ ∣ s , a ) p(s'\mid s,a) p(s′∣s,a) 与 p ( r ∣ s , a ) p(r\mid s,a) p(r∣s,a),但一般情况下 S t + 1 S_{t+1} St+1 和 R t + 1 R_{t+1} Rt+1 可能不独立,所以用联合形式 p ( s ′ , r ∣ s , a ) p(s',r\mid s,a) p(s′,r∣s,a) 更严谨。

Markov 性质指的是:给定当前状态和当前动作之后,未来只依赖当前,而不依赖更早的历史:

Pr ⁡ ( S t + 1 = s ′ , R t + 1 = r ∣ S 0 , A 0 , R 1 , ... , S t , A t ) = p ( s ′ , r ∣ S t , A t ) \Pr(S_{t+1}=s', R_{t+1}=r \mid S_0,A_0,R_1,\dots,S_t,A_t) = p(s',r \mid S_t,A_t) Pr(St+1=s′,Rt+1=r∣S0,A0,R1,...,St,At)=p(s′,r∣St,At)
#mermaid-svg-s6aYoD3H6D2xv4pZ{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-s6aYoD3H6D2xv4pZ .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-s6aYoD3H6D2xv4pZ .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-s6aYoD3H6D2xv4pZ .error-icon{fill:#552222;}#mermaid-svg-s6aYoD3H6D2xv4pZ .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-s6aYoD3H6D2xv4pZ .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-s6aYoD3H6D2xv4pZ .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-s6aYoD3H6D2xv4pZ .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-s6aYoD3H6D2xv4pZ .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-s6aYoD3H6D2xv4pZ .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-s6aYoD3H6D2xv4pZ .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-s6aYoD3H6D2xv4pZ .marker{fill:#333333;stroke:#333333;}#mermaid-svg-s6aYoD3H6D2xv4pZ .marker.cross{stroke:#333333;}#mermaid-svg-s6aYoD3H6D2xv4pZ svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-s6aYoD3H6D2xv4pZ p{margin:0;}#mermaid-svg-s6aYoD3H6D2xv4pZ .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-s6aYoD3H6D2xv4pZ .cluster-label text{fill:#333;}#mermaid-svg-s6aYoD3H6D2xv4pZ .cluster-label span{color:#333;}#mermaid-svg-s6aYoD3H6D2xv4pZ .cluster-label span p{background-color:transparent;}#mermaid-svg-s6aYoD3H6D2xv4pZ .label text,#mermaid-svg-s6aYoD3H6D2xv4pZ span{fill:#333;color:#333;}#mermaid-svg-s6aYoD3H6D2xv4pZ .node rect,#mermaid-svg-s6aYoD3H6D2xv4pZ .node circle,#mermaid-svg-s6aYoD3H6D2xv4pZ .node ellipse,#mermaid-svg-s6aYoD3H6D2xv4pZ .node polygon,#mermaid-svg-s6aYoD3H6D2xv4pZ .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-s6aYoD3H6D2xv4pZ .rough-node .label text,#mermaid-svg-s6aYoD3H6D2xv4pZ .node .label text,#mermaid-svg-s6aYoD3H6D2xv4pZ .image-shape .label,#mermaid-svg-s6aYoD3H6D2xv4pZ .icon-shape .label{text-anchor:middle;}#mermaid-svg-s6aYoD3H6D2xv4pZ .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-s6aYoD3H6D2xv4pZ .rough-node .label,#mermaid-svg-s6aYoD3H6D2xv4pZ .node .label,#mermaid-svg-s6aYoD3H6D2xv4pZ .image-shape .label,#mermaid-svg-s6aYoD3H6D2xv4pZ .icon-shape .label{text-align:center;}#mermaid-svg-s6aYoD3H6D2xv4pZ .node.clickable{cursor:pointer;}#mermaid-svg-s6aYoD3H6D2xv4pZ .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-s6aYoD3H6D2xv4pZ .arrowheadPath{fill:#333333;}#mermaid-svg-s6aYoD3H6D2xv4pZ .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-s6aYoD3H6D2xv4pZ .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-s6aYoD3H6D2xv4pZ .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-s6aYoD3H6D2xv4pZ .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-s6aYoD3H6D2xv4pZ .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-s6aYoD3H6D2xv4pZ .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-s6aYoD3H6D2xv4pZ .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-s6aYoD3H6D2xv4pZ .cluster text{fill:#333;}#mermaid-svg-s6aYoD3H6D2xv4pZ .cluster span{color:#333;}#mermaid-svg-s6aYoD3H6D2xv4pZ div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-s6aYoD3H6D2xv4pZ .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-s6aYoD3H6D2xv4pZ rect.text{fill:none;stroke-width:0;}#mermaid-svg-s6aYoD3H6D2xv4pZ .icon-shape,#mermaid-svg-s6aYoD3H6D2xv4pZ .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-s6aYoD3H6D2xv4pZ .icon-shape p,#mermaid-svg-s6aYoD3H6D2xv4pZ .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-s6aYoD3H6D2xv4pZ .icon-shape .label rect,#mermaid-svg-s6aYoD3H6D2xv4pZ .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-s6aYoD3H6D2xv4pZ .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-s6aYoD3H6D2xv4pZ .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-s6aYoD3H6D2xv4pZ :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 智能体选动作 A_t
环境反馈
循环
Markov 性质
状态 S_t
动作 A_t
奖励 R_{t+1}

新状态 S_{t+1}
未来只依赖

(S_t, A_t)

不依赖更早历史

三、策略与轨迹

MDP 定义了环境,智能体在其中交互来学习一个策略(policy),使得能获得更多奖励。随机策略写作:

π ( a ∣ s ) = Pr ⁡ ( A t = a ∣ S t = s ) \pi(a \mid s) = \Pr(A_t=a \mid S_t=s) π(a∣s)=Pr(At=a∣St=s)

从某个初始状态出发,交互会生成一条随机轨迹(trajectory):

τ = ( S 0 , A 0 , R 1 , S 1 , A 1 , R 2 , S 2 , ... ) \tau = (S_0,A_0,R_1,S_1,A_1,R_2,S_2,\dots) τ=(S0,A0,R1,S1,A1,R2,S2,...)

给定初始状态分布 ρ 0 ( s 0 ) \rho_0(s_0) ρ0(s0)、策略 π \pi π、环境动态 p p p,一条有限轨迹的概率是:

Pr ⁡ ( τ 0 : T ) = ρ 0 ( s 0 ) ∏ t = 0 T − 1 π ( a t ∣ s t ) p ( s t + 1 , r t + 1 ∣ s t , a t ) \Pr(\tau_{0:T}) = \rho_0(s_0)\prod_{t=0}^{T-1}\pi(a_t\mid s_t)p(s_{t+1},r_{t+1}\mid s_t,a_t) Pr(τ0:T)=ρ0(s0)t=0∏T−1π(at∣st)p(st+1,rt+1∣st,at)

这个公式把 RL 中的两类随机性都写了出来:

π ( a t ∣ s t ) \pi(a_t\mid s_t) π(at∣st):智能体选择动作的随机性;
p ( s t + 1 , r t + 1 ∣ s t , a t ) p(s_{t+1},r_{t+1}\mid s_t,a_t) p(st+1,rt+1∣st,at):环境反馈的随机性。

四、Return:定义"表现好坏"

Return 的意义是定义智能体表现的好与坏。从时刻 t t t 开始,未来能获得的折扣奖励和称为 return:

G t = R t + 1 + γ R t + 2 + γ 2 R t + 3 + ⋯ = ∑ k = 0 ∞ γ k R t + k + 1 G_t = R_{t+1} + \gamma R_{t+2} + \gamma^2 R_{t+3} + \cdots = \sum_{k=0}^{\infty}\gamma^k R_{t+k+1} Gt=Rt+1+γRt+2+γ2Rt+3+⋯=k=0∑∞γkRt+k+1

γ \gamma γ 是衰减系数------越未来得到的奖励,其重要性就在下降。

Return 还有一个极其重要的递推形式:

G t = R t + 1 + γ G t + 1 G_t = R_{t+1} + \gamma G_{t+1} Gt=Rt+1+γGt+1

这个递推是后面 Bellman 方程和 TD learning 的源头。

五、State value:对 return 取期望

我们希望关注每个 state 上能获得的 return 是多少,这就是 State value 的定义。由于 return 又是随机变量,所以用期望来衡量:

v π ( s ) = E π $G t ∣ S t = s$ v_\pi(s) = \mathbb{E}_\pi $G_t \\mid S_t=s$ vπ(s)=Eπ $Gt∣St=s$

更直接地说,state value 是"从某个状态出发,在策略 π \pi π 下所有可能 return 的平均值"。如果策略和环境都是确定性的,从 s s s 出发只会产生一条轨迹,此时 v π ( s ) v_\pi(s) vπ(s) 就等于这条轨迹的 return。

六、Q value / Action value

Action value(常称 Q value)描述的是:在策略 π \pi π 下,从状态 s s s 出发,先采取动作 a a a ,之后继续按策略 π \pi π 行动,未来能得到的期望 return:

q π ( s , a ) = E π $G t ∣ S t = s , A t = a$ q_\pi(s,a) = \mathbb{E}_\pi $G_t \\mid S_t=s, A_t=a$ qπ(s,a)=Eπ $Gt∣St=s,At=a$

State value 和 Q value 的区别在于条件不同:

v π ( s ) v_\pi(s) vπ(s) 只固定当前状态,动作仍按 π ( a ∣ s ) \pi(a\mid s) π(a∣s) 抽样;
q π ( s , a ) q_\pi(s,a) qπ(s,a) 同时固定当前状态和当前动作。

因此 Q value 更适合用来比较"在同一个状态下,哪个动作更好"。

用全期望公式 (law of total expectation)可以推出两者的关系。令 X = G t X=G_t X=Gt, Y = ( S t = s ) Y=(S_t=s) Y=(St=s), Z = A t Z=A_t Z=At:

v π ( s ) = E A t ∼ π ( ⋅ ∣ s ) $q π ( s , A t )$ = ∑ a ∈ A ( s ) π ( a ∣ s ) q π ( s , a ) v_\pi(s) = \mathbb{E}{A_t\sim\pi(\cdot\mid s)}\left $q_\\pi(s,A_t)\\right$ = \sum{a\in\mathcal{A}(s)}\pi(a\mid s)q_\pi(s,a) vπ(s)=EAt∼π(⋅∣s) $qπ(s,At)$ =a∈A(s)∑π(a∣s)qπ(s,a)

含义:状态价值等于在该状态下按策略选择动作后,所有动作价值的加权平均。

第二部分:Bellman 方程

七、Bellman expectation equation

Bellman 方程是 RL 里最核心的公式之一,作用是把"一个状态的价值"写成"一步奖励"和"下一个状态价值"的关系。它本质上来自 return 的递推定义 G t = R t + 1 + γ G t + 1 G_t = R_{t+1} + \gamma G_{t+1} Gt=Rt+1+γGt+1。

把递推代入 state value 定义,再把当前动作 A t A_t At、下一状态 S t + 1 S_{t+1} St+1、奖励 R t + 1 R_{t+1} Rt+1 全部展开:

v π ( s ) = ∑ a ∈ A ( s ) π ( a ∣ s ) ∑ s ′ ∈ S ∑ r ∈ R p ( s ′ , r ∣ s , a ) $r + γ v π ( s ' )$ v_\pi(s) = \sum_{a\in\mathcal{A}(s)}\pi(a\mid s)\sum_{s'\in\mathcal{S}}\sum_{r\in\mathcal{R}}p(s',r\mid s,a)\left $r+\\gamma v_\\pi(s')\\right$ vπ(s)=a∈A(s)∑π(a∣s)s′∈S∑r∈R∑p(s′,r∣s,a) $r+γvπ(s')$

每一层求和都有明确含义:

∑ a π ( a ∣ s ) \sum_a \pi(a\mid s) ∑aπ(a∣s):在状态 s s s 下,策略可能选择不同动作;
∑ s ′ ∑ r p ( s ′ , r ∣ s , a ) \sum_{s'}\sum_r p(s',r\mid s,a) ∑s′∑rp(s′,r∣s,a):给定状态和动作后,环境可能返回不同的下一状态和奖励;
r + γ v π ( s ′ ) r+\gamma v_\pi(s') r+γvπ(s′):当前一步奖励,加上下一个状态的折扣价值。

如果先定义 Q value,方程可以写得更紧凑: v π ( s ) = ∑ a π ( a ∣ s ) q π ( s , a ) v_\pi(s)=\sum_a \pi(a\mid s)q_\pi(s,a) vπ(s)=∑aπ(a∣s)qπ(s,a)。

八、矩阵形式:policy evaluation 就是解线性方程组

如果状态空间有限 S = { s 1 , ... , s n } \mathcal{S}=\{s_1,\dots,s_n\} S={s1,...,sn},把所有状态的 value 放进向量 v π \mathbf{v}\pi vπ,定义平均即时奖励 r π \mathbf{r}\pi rπ 和策略诱导的状态转移矩阵 P π \mathbf{P}_\pi Pπ:

$P π$ i j = p π ( s j ∣ s i ) = ∑ a ∈ A ( s i ) π ( a ∣ s i ) ∑ r ∈ R p ( s j , r ∣ s i , a ) $\\mathbf{P}_\\pi$ {ij} = p\pi(s_j\mid s_i) = \sum_{a\in\mathcal{A}(s_i)}\pi(a\mid s_i)\sum_{r\in\mathcal{R}}p(s_j,r\mid s_i,a) $Pπ$ ij=pπ(sj∣si)=a∈A(si)∑π(a∣si)r∈R∑p(sj,r∣si,a)

于是 Bellman 方程可以写成非常简洁的矩阵形式:

v π = r π + γ P π v π ⟹ ( I − γ P π ) v π = r π \mathbf{v}\pi = \mathbf{r}\pi + \gamma \mathbf{P}\pi \mathbf{v}\pi \quad\Longrightarrow\quad (\mathbf{I}-\gamma\mathbf{P}\pi)\mathbf{v}\pi = \mathbf{r}_\pi vπ=rπ+γPπvπ⟹(I−γPπ)vπ=rπ

如果 I − γ P π \mathbf{I}-\gamma\mathbf{P}_\pi I−γPπ 可逆,就有闭式解:

v π = ( I − γ P π ) − 1 r π \mathbf{v}\pi = (\mathbf{I}-\gamma\mathbf{P}\pi)^{-1}\mathbf{r}_\pi vπ=(I−γPπ)−1rπ

这个矩阵形式很重要,因为它说明:在给定策略 π \pi π 的情况下,求 state value 本质上是在解一个线性方程组 。这个问题也称为 policy evaluation。

九、Bellman 最优方程与最优策略

前面都在"给定策略 π \pi π"的前提下讨论。接下来的问题是:什么样的策略最优?

定义策略偏序:如果对所有 s s s 都有 v π 1 ( s ) ≥ v π 2 ( s ) v_{\pi_1}(s)\ge v_{\pi_2}(s) vπ1(s)≥vπ2(s),记作 π 1 ⪰ π 2 \pi_1 \succeq \pi_2 π1⪰π2。若 π ∗ \pi^* π∗ 对任意 π \pi π 都满足 v π ∗ ( s ) ≥ v π ( s ) v_{\pi^*}(s)\ge v_\pi(s) vπ∗(s)≥vπ(s)(对所有 s s s),则 π ∗ \pi^* π∗ 是最优策略,对应:

v ∗ ( s ) = max ⁡ π v π ( s ) v^*(s) = \max_\pi v_\pi(s) v∗(s)=πmaxvπ(s)

最优策略的关键在于:如果已经知道每个动作带来的未来价值,那么在每个状态下都应该选择价值最大的动作。因此 Bellman expectation equation 中的"按策略加权平均"在最优情况下变成"对动作取最大值":

v ∗ ( s ) = max ⁡ a ∈ A ( s ) ∑ s ′ ∈ S ∑ r ∈ R p ( s ′ , r ∣ s , a ) $r + γ v * ( s ' )$ v^*(s) = \max_{a\in\mathcal{A}(s)}\sum_{s'\in\mathcal{S}}\sum_{r\in\mathcal{R}}p(s',r\mid s,a)\left $r+\\gamma v\^\*(s')\\right$ v∗(s)=a∈A(s)maxs′∈S∑r∈R∑p(s′,r∣s,a) $r+γv*(s')$

这就是 Bellman optimality equation。

9.1 解的存在性与唯一性

在有限状态、有限动作,且 0 ≤ γ < 1 0\le\gamma<1 0≤γ<1 的 discounted MDP 中,最优 state value v ∗ v^* v∗ 一定存在且唯一。

原因从 Bellman optimality operator 理解:

( T v ) ( s ) = max ⁡ a ∈ A ( s ) ∑ s ′ ∈ S ∑ r ∈ R p ( s ′ , r ∣ s , a ) $r + γ v ( s ' )$ (\mathcal{T}v)(s) = \max_{a\in\mathcal{A}(s)}\sum_{s'\in\mathcal{S}}\sum_{r\in\mathcal{R}}p(s',r\mid s,a)\left $r+\\gamma v(s')\\right$ (Tv)(s)=a∈A(s)maxs′∈S∑r∈R∑p(s′,r∣s,a) $r+γv(s')$

矩阵形式 T v = max ⁡ π ( r π + γ P π v ) \mathcal{T}\mathbf{v} = \max_\pi(\mathbf{r}\pi + \gamma\mathbf{P}\pi\mathbf{v}) Tv=maxπ(rπ+γPπv)。注意这里的 max ⁡ π \max_\pi maxπ 不是对整个向量取标量最大值,而是对每个状态分别选择能让该状态右侧取到最大值的动作 。换句话说,这个 operator 做的就是:给定当前价值估计 v \mathbf{v} v,在每个状态上做一次 greedy 的 Bellman backup。

Bellman optimality equation 就是不动点方程 v = T v v = \mathcal{T}v v=Tv。当 0 ≤ γ < 1 0\le\gamma<1 0≤γ<1 时, T \mathcal{T} T 是 contraction mapping ,根据 contraction mapping theorem 它有唯一不动点,即 v ∗ v^* v∗。

重要细节 :唯一的是最优价值函数 v ∗ v^* v∗,不一定是最优策略 π ∗ \pi^* π∗。如果某个状态下有多个动作同时达到最大 action value,这些动作都可以构成最优策略,因此最优策略可能不唯一。

对应地,最优 Q value 满足:

q ∗ ( s , a ) = ∑ s ′ ∑ r p ( s ′ , r ∣ s , a ) $r + γ max a ' q * ( s ' , a ' )$ q^*(s,a) = \sum_{s'}\sum_{r}p(s',r\mid s,a)\left $r+\\gamma\\max_{a'}q\^\*(s',a')\\right$ q∗(s,a)=s′∑r∑p(s′,r∣s,a) $r+γa'maxq*(s',a')$

已知 q ∗ ( s , a ) q^*(s,a) q∗(s,a) 时,确定性 greedy 策略为 π ∗ ( s ) ∈ arg ⁡ max ⁡ a q ∗ ( s , a ) \pi^*(s)\in\arg\max_a q^*(s,a) π∗(s)∈argmaxaq∗(s,a)。

第三部分:传统算法脉络(DP → MC → TD)

这一节主要对应课程第 4~8 节及第 10 节内容。如果主要目标是理解 LLM 中的 RLHF、PPO、GRPO,不需要逐个公式深入推导,更重要的是掌握它们试图解决什么问题、属于哪一类方法,以及引入了哪些后来反复出现的概念。
#mermaid-svg-ciJMk14tTirPXeoe{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-ciJMk14tTirPXeoe .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-ciJMk14tTirPXeoe .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-ciJMk14tTirPXeoe .error-icon{fill:#552222;}#mermaid-svg-ciJMk14tTirPXeoe .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-ciJMk14tTirPXeoe .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-ciJMk14tTirPXeoe .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-ciJMk14tTirPXeoe .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-ciJMk14tTirPXeoe .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-ciJMk14tTirPXeoe .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-ciJMk14tTirPXeoe .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-ciJMk14tTirPXeoe .marker{fill:#333333;stroke:#333333;}#mermaid-svg-ciJMk14tTirPXeoe .marker.cross{stroke:#333333;}#mermaid-svg-ciJMk14tTirPXeoe svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-ciJMk14tTirPXeoe p{margin:0;}#mermaid-svg-ciJMk14tTirPXeoe .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-ciJMk14tTirPXeoe .cluster-label text{fill:#333;}#mermaid-svg-ciJMk14tTirPXeoe .cluster-label span{color:#333;}#mermaid-svg-ciJMk14tTirPXeoe .cluster-label span p{background-color:transparent;}#mermaid-svg-ciJMk14tTirPXeoe .label text,#mermaid-svg-ciJMk14tTirPXeoe span{fill:#333;color:#333;}#mermaid-svg-ciJMk14tTirPXeoe .node rect,#mermaid-svg-ciJMk14tTirPXeoe .node circle,#mermaid-svg-ciJMk14tTirPXeoe .node ellipse,#mermaid-svg-ciJMk14tTirPXeoe .node polygon,#mermaid-svg-ciJMk14tTirPXeoe .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-ciJMk14tTirPXeoe .rough-node .label text,#mermaid-svg-ciJMk14tTirPXeoe .node .label text,#mermaid-svg-ciJMk14tTirPXeoe .image-shape .label,#mermaid-svg-ciJMk14tTirPXeoe .icon-shape .label{text-anchor:middle;}#mermaid-svg-ciJMk14tTirPXeoe .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-ciJMk14tTirPXeoe .rough-node .label,#mermaid-svg-ciJMk14tTirPXeoe .node .label,#mermaid-svg-ciJMk14tTirPXeoe .image-shape .label,#mermaid-svg-ciJMk14tTirPXeoe .icon-shape .label{text-align:center;}#mermaid-svg-ciJMk14tTirPXeoe .node.clickable{cursor:pointer;}#mermaid-svg-ciJMk14tTirPXeoe .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-ciJMk14tTirPXeoe .arrowheadPath{fill:#333333;}#mermaid-svg-ciJMk14tTirPXeoe .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-ciJMk14tTirPXeoe .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-ciJMk14tTirPXeoe .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-ciJMk14tTirPXeoe .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-ciJMk14tTirPXeoe .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-ciJMk14tTirPXeoe .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-ciJMk14tTirPXeoe .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-ciJMk14tTirPXeoe .cluster text{fill:#333;}#mermaid-svg-ciJMk14tTirPXeoe .cluster span{color:#333;}#mermaid-svg-ciJMk14tTirPXeoe div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-ciJMk14tTirPXeoe .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-ciJMk14tTirPXeoe rect.text{fill:none;stroke-width:0;}#mermaid-svg-ciJMk14tTirPXeoe .icon-shape,#mermaid-svg-ciJMk14tTirPXeoe .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-ciJMk14tTirPXeoe .icon-shape p,#mermaid-svg-ciJMk14tTirPXeoe .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-ciJMk14tTirPXeoe .icon-shape .label rect,#mermaid-svg-ciJMk14tTirPXeoe .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-ciJMk14tTirPXeoe .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-ciJMk14tTirPXeoe .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-ciJMk14tTirPXeoe :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 去掉模型假设
不用等完整episode
状态空间太大
直接优化策略
需要环境模型

(Model-based DP)
Monte Carlo

(采样完整return)
TD Learning

(bootstrapping)
Sarsa (on-policy)

Q-learning (off-policy)
函数逼近

FA-Sarsa / FA-Q / DQN
Policy Gradient

Actor-Critic

十、Value iteration 与 Policy iteration

Q:Value iteration 是什么?

求解 Bellman optimality equation 的动态规划算法,直接逼近最优价值函数 v ∗ v^* v∗,再据此得到最优策略:

v k + 1 ( s ) = ( T v k ) ( s ) = max ⁡ a ∈ A ( s ) ∑ s ′ ∑ r p ( s ′ , r ∣ s , a ) $r + γ v k ( s ' )$ v_{k+1}(s) = (\mathcal{T}v_k)(s) = \max_{a\in\mathcal{A}(s)}\sum_{s'}\sum_{r}p(s',r\mid s,a)\left $r+\\gamma v_k(s')\\right$ vk+1(s)=(Tvk)(s)=a∈A(s)maxs′∑r∑p(s′,r∣s,a) $r+γvk(s')$

直观上,它每一步都在问:如果我现在对下一状态的价值估计是 v k v_k vk,那么当前状态下最好的动作会带来多少价值?反复更新后 v k v_k vk 逐渐逼近 v ∗ v^* v∗。前提是 model 已知。

Q:Policy iteration 是什么?

不是直接迭代最优价值函数,而是在"评估当前策略"和"改进当前策略"之间交替:

Policy evaluation :给定 π k \pi_k πk,计算 v π k v_{\pi_k} vπk(解普通 Bellman 方程);
Policy improvement :根据 v π k v_{\pi_k} vπk 构造更好的 π k + 1 \pi_{k+1} πk+1(每个状态选 greedy action)。

π 0 → evaluation v π 0 → improvement π 1 → evaluation v π 1 → improvement ⋯ \pi_0 \xrightarrow{\text{evaluation}} v_{\pi_0} \xrightarrow{\text{improvement}} \pi_1 \xrightarrow{\text{evaluation}} v_{\pi_1} \xrightarrow{\text{improvement}} \cdots π0evaluation vπ0improvement π1evaluation vπ1improvement ⋯

同样需要 model 已知。

Q:两者有什么区别? 都属于 model-based,区别在"评估策略"的程度:

Policy iteration:每一步更重,通常迭代次数更少;
Value iteration:每一步更轻,通常需要更多轮迭代。

Q:Truncated policy iteration 是什么? 介于两者之间------在 policy evaluation 里只做有限步迭代,然后立刻做 policy improvement。这形成了一个连续谱:

方法	policy evaluation 做多少
Value iteration	只做一步
Truncated policy iteration	做有限步
Policy iteration	做到充分收敛

这个视角很重要:很多 RL 算法并不是完全割裂的,而是在"评估多少"和"改进多快"之间做不同折中。

十一、Monte Carlo Learning

Q:MC 在 RL 里做什么?

核心思想是用采样平均来估计期望 。 v π ( s ) v_\pi(s) vπ(s) 和 q π ( s , a ) q_\pi(s,a) qπ(s,a) 本来就是期望,如果环境模型未知,无法直接算,但可以让智能体真实地跑很多条轨迹,用平均 return 估计 value。所以 MC 是 model-free 方法。

Q:MC Basic 是什么? 可以看作 policy iteration 的 model-free 版本:

q π k ( s , a ) ≈ 1 N ∑ i = 1 N g ( i ) ( s , a ) q_{\pi_k}(s,a) \approx \frac{1}{N}\sum_{i=1}^{N}g^{(i)}(s,a) qπk(s,a)≈N1i=1∑Ng(i)(s,a)

估计出 q q q 之后做 greedy policy improvement。核心问题是效率低 ------为估计每个 ( s , a ) (s,a) (s,a) 可能需要从大量 state-action pair 分别出发采样。

完整的 MC control 循环:初始化 q , π q,\pi q,π → 按 π \pi π 采样完整 episode → 从末尾往前算 return → 更新访问到的 ( s t , a t ) (s_t,a_t) (st,at) → 改进策略 → 重复。

MC 和 TD 最大的差别是:MC 必须等 return 完整出现,而 TD 可以在每一步之后立刻更新。

Q:Exploring Starts 是什么? MC 中的一个理论条件,要求每个 ( s , a ) (s,a) (s,a) 都有机会作为 episode 起点。因为如果某个动作从未被采样过,就无法估计它的 q π ( s , a ) q_\pi(s,a) qπ(s,a)------而一个从未被尝试的动作,理论上可能恰好是最优动作。但真实任务里它经常不现实(很多环境不允许任意指定初始状态和动作)。

Q:ε-greedy MC 是什么? 目标是去掉 exploring starts 这个强假设,通过 soft policy 保证每个动作都有非零概率被选中:

π ( a ∣ s ) = { 1 − ϵ + ϵ ∣ A ( s ) ∣ , a = a ∗ ( s ) ϵ ∣ A ( s ) ∣ , a ≠ a ∗ ( s ) \pi(a\mid s)=\begin{cases}1-\epsilon+\frac{\epsilon}{|\mathcal{A}(s)|}, & a=a^*(s)\\\frac{\epsilon}{|\mathcal{A}(s)|}, & a\ne a^*(s)\end{cases} π(a∣s)={1−ϵ+∣A(s)∣ϵ,∣A(s)∣ϵ,a=a∗(s)a=a∗(s)

意义是平衡 exploration 和 exploitation:大概率选择当前看起来最好的动作,小概率尝试其他动作。

十二、Temporal-Difference Learning

Q:TD learning 是什么? RL 里非常核心的一类 model-free 算法,目标是在不需要环境模型的情况下从经验样本中估计 value。最基础的 TD state value update:

v t + 1 ( s t ) = v t ( s t ) + α t $r t + 1 + γ v t ( s t + 1 ) - v t ( s t )$ ⏟ TD error v_{t+1}(s_t) = v_t(s_t) + \alpha_t\underbrace{\left $r_{t+1}+\\gamma v_t(s_{t+1}) - v_t(s_t)\\right$ }_{\text{TD error}} vt+1(st)=vt(st)+αtTD error $rt+1+γvt(st+1)-vt(st)$

r t + 1 + γ v t ( s t + 1 ) r_{t+1}+\gamma v_t(s_{t+1}) rt+1+γvt(st+1) 称为 TD target;
方括号整体称为 TD error。

TD 的关键特征是 bootstrapping :它用当前估计出来的 v t ( s t + 1 ) v_t(s_{t+1}) vt(st+1) 作为目标的一部分,因此不需要等一整条 episode 结束就能更新。

12.1 TD vs MC

维度	MC	TD
使用	完整 return G t G_t Gt	一步 TD target R t + 1 + γ v t ( S t + 1 ) R_{t+1}+\gamma v_t(S_{t+1}) Rt+1+γvt(St+1)
何时更新	必须等 episode 结束	每走一步就可以更新
bootstrapping	否	是
方差	通常更大	通常更小
bias	相对更小	引入来自当前估计的 bias
continuing task	不适用	可以处理

12.2 On-policy 与 Off-policy:先区分两个策略

理解 Sarsa 和 Q-learning 的关键是区分:

Behavior policy β \beta β:实际和环境交互、产生样本的策略;
Target policy π \pi π:算法真正想评估或优化的策略。
二者相同 → on-policy ( β = π \beta=\pi β=π);
二者可以不同 → off-policy ( β ≠ π \beta\ne\pi β=π)。

这个定义放在 Sarsa 和 Q-learning 前面非常重要,因为二者的核心差别不只是 TD target 长得不一样,而是它们学习的目标策略不同。

Q:Sarsa 是什么? TD learning 在 action value 上的版本,名字来自更新需要的五元组 ( S t , A t , R t + 1 , S t + 1 , A t + 1 ) (S_t,A_t,R_{t+1},S_{t+1},A_{t+1}) (St,At,Rt+1,St+1,At+1):

q t + 1 ( s t , a t ) = q t ( s t , a t ) + α t $r t + 1 + γ q t ( s t + 1 , a t + 1 ) - q t ( s t , a t )$ q_{t+1}(s_t,a_t) = q_t(s_t,a_t) + \alpha_t\left $r_{t+1}+\\gamma q_t(s_{t+1},a_{t+1}) - q_t(s_t,a_t)\\right$ qt+1(st,at)=qt(st,at)+αt $rt+1+γqt(st+1,at+1)-qt(st,at)$

因为 a t + 1 a_{t+1} at+1 是按当前策略 π \pi π 采样出来的,所以 Sarsa 是 on-policy------它怎么采样就怎么学习,学习的正是当前正在执行的策略。

Q:n-step Sarsa 是什么? 介于 one-step Sarsa 和 MC 之间,target 看未来 n n n 步奖励再接上第 n n n 步后的 value 估计:

R t + 1 + γ R t + 2 + ⋯ + γ n − 1 R t + n + γ n q t ( S t + n , A t + n ) R_{t+1}+\gamma R_{t+2}+\cdots+\gamma^{n-1}R_{t+n}+\gamma^n q_t(S_{t+n},A_{t+n}) Rt+1+γRt+2+⋯+γn−1Rt+n+γnqt(St+n,At+n)

n = 1 n=1 n=1 就是普通 Sarsa; n n n 趋近 episode 长度就接近 MC。所以它是在 bias 和 variance 之间调节: n n n 小更像 TD(更新快、方差小、bootstrap bias 更强), n n n 大更像 MC(bias 小、方差更大)。

Q:Q-learning 是什么? 直接估计最优 action value q ∗ ( s , a ) q^*(s,a) q∗(s,a):

q t + 1 ( s t , a t ) = q t ( s t , a t ) + α t $r t + 1 + γ max a \in A ( s t + 1 ) q t ( s t + 1 , a ) - q t ( s t , a t )$ q_{t+1}(s_t,a_t) = q_t(s_t,a_t) + \alpha_t\left $r_{t+1}+\\gamma\\max_{a\\in\\mathcal{A}(s_{t+1})}q_t(s_{t+1},a) - q_t(s_t,a_t)\\right$ qt+1(st,at)=qt(st,at)+αt $rt+1+γa\inA(st+1)maxqt(st+1,a)-qt(st,at)$

和 Sarsa 的区别在 target:Sarsa 使用实际采样到的 a t + 1 a_{t+1} at+1;Q-learning 使用下一状态下的最大 action value 。因此 Q-learning 的目标策略是 greedy,但行为策略可以是别的探索策略,所以是 off-policy------可以一边探索,一边学习 greedy 最优策略。
#mermaid-svg-CHIsDE0SgZ50db2n{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-CHIsDE0SgZ50db2n .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-CHIsDE0SgZ50db2n .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-CHIsDE0SgZ50db2n .error-icon{fill:#552222;}#mermaid-svg-CHIsDE0SgZ50db2n .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-CHIsDE0SgZ50db2n .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-CHIsDE0SgZ50db2n .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-CHIsDE0SgZ50db2n .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-CHIsDE0SgZ50db2n .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-CHIsDE0SgZ50db2n .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-CHIsDE0SgZ50db2n .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-CHIsDE0SgZ50db2n .marker{fill:#333333;stroke:#333333;}#mermaid-svg-CHIsDE0SgZ50db2n .marker.cross{stroke:#333333;}#mermaid-svg-CHIsDE0SgZ50db2n svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-CHIsDE0SgZ50db2n p{margin:0;}#mermaid-svg-CHIsDE0SgZ50db2n .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-CHIsDE0SgZ50db2n .cluster-label text{fill:#333;}#mermaid-svg-CHIsDE0SgZ50db2n .cluster-label span{color:#333;}#mermaid-svg-CHIsDE0SgZ50db2n .cluster-label span p{background-color:transparent;}#mermaid-svg-CHIsDE0SgZ50db2n .label text,#mermaid-svg-CHIsDE0SgZ50db2n span{fill:#333;color:#333;}#mermaid-svg-CHIsDE0SgZ50db2n .node rect,#mermaid-svg-CHIsDE0SgZ50db2n .node circle,#mermaid-svg-CHIsDE0SgZ50db2n .node ellipse,#mermaid-svg-CHIsDE0SgZ50db2n .node polygon,#mermaid-svg-CHIsDE0SgZ50db2n .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-CHIsDE0SgZ50db2n .rough-node .label text,#mermaid-svg-CHIsDE0SgZ50db2n .node .label text,#mermaid-svg-CHIsDE0SgZ50db2n .image-shape .label,#mermaid-svg-CHIsDE0SgZ50db2n .icon-shape .label{text-anchor:middle;}#mermaid-svg-CHIsDE0SgZ50db2n .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-CHIsDE0SgZ50db2n .rough-node .label,#mermaid-svg-CHIsDE0SgZ50db2n .node .label,#mermaid-svg-CHIsDE0SgZ50db2n .image-shape .label,#mermaid-svg-CHIsDE0SgZ50db2n .icon-shape .label{text-align:center;}#mermaid-svg-CHIsDE0SgZ50db2n .node.clickable{cursor:pointer;}#mermaid-svg-CHIsDE0SgZ50db2n .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-CHIsDE0SgZ50db2n .arrowheadPath{fill:#333333;}#mermaid-svg-CHIsDE0SgZ50db2n .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-CHIsDE0SgZ50db2n .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-CHIsDE0SgZ50db2n .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-CHIsDE0SgZ50db2n .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-CHIsDE0SgZ50db2n .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-CHIsDE0SgZ50db2n .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-CHIsDE0SgZ50db2n .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-CHIsDE0SgZ50db2n .cluster text{fill:#333;}#mermaid-svg-CHIsDE0SgZ50db2n .cluster span{color:#333;}#mermaid-svg-CHIsDE0SgZ50db2n div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-CHIsDE0SgZ50db2n .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-CHIsDE0SgZ50db2n rect.text{fill:none;stroke-width:0;}#mermaid-svg-CHIsDE0SgZ50db2n .icon-shape,#mermaid-svg-CHIsDE0SgZ50db2n .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-CHIsDE0SgZ50db2n .icon-shape p,#mermaid-svg-CHIsDE0SgZ50db2n .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-CHIsDE0SgZ50db2n .icon-shape .label rect,#mermaid-svg-CHIsDE0SgZ50db2n .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-CHIsDE0SgZ50db2n .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-CHIsDE0SgZ50db2n .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-CHIsDE0SgZ50db2n :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 按当前策略采样 a_{t+1}
对下一状态取 max q
TD control:更新 target 怎么构造?
target 里的下一步动作

怎么来?
Sarsa

on-policy
Q-learning

off-policy
学的是当前策略的价值

采样策略=学习策略
学的是 greedy 最优价值

采样策略≠学习策略

Q:TD 算法属于 general algorithm 还是 RL 算法?

TD 本身是 RL 算法------它的对象是 value function,样本来自 agent 与环境交互,要解决 Bellman 方程。但它的理论解释可以借助 general stochastic approximation(Robbins-Monro),即形式上都是:

new estimate = old estimate + α $target - old estimate$ \text{new estimate} = \text{old estimate} + \alpha\left $\\text{target} - \\text{old estimate}\\right$ new estimate=old estimate+α $target-old estimate$

所以更准确地说:TD 是 RL 算法,但它的理论解释可以借助 general stochastic approximation。

第四部分:函数逼近

十三、为什么需要 value function approximation?

前面的算法默认 value 可以用表格存储。但如果状态空间很大甚至连续,表格方法会遇到两个问题:

存储困难:状态太多,无法给每个状态单独存一个值;
泛化能力弱:表格只记住见过的状态,不能自然泛化到相似但没见过的状态。

Value function approximation 用参数化函数近似 value:

v ^ ( s , w ) ≈ v π ( s ) , q ^ ( s , a , w ) ≈ q π ( s , a ) \hat{v}(s,w)\approx v_\pi(s), \qquad \hat{q}(s,a,w)\approx q_\pi(s,a) v^(s,w)≈vπ(s),q^(s,a,w)≈qπ(s,a)

其中 w w w 是参数(线性模型权重或神经网络参数)。

从 tabular 到 function approximation 发生了什么变化?

tabular:更新一个状态的 value 只改变表格中的一个 entry;
FA:更新的是参数 w w w,因为多个状态共享同一组参数,所以一次更新可能同时影响很多状态的 value 估计。

这带来两个结果:

好处:可以把一个状态上学到的信息泛化到相似状态;
风险:更新一个状态时,也可能破坏其他状态上的估计。

这也是为什么 function approximation 之后,优化稳定性会变得更重要。

十四、Sarsa / Q-learning with Function Approximation

TD target 的来历 :我们希望 q ^ ( s t , a t , w ) \hat{q}(s_t,a_t,w) q^(st,at,w) 逼近真实的 q π ( s t , a t ) q_\pi(s_t,a_t) qπ(st,at)。根据 Bellman expectation equation,真实值满足:

q π ( s t , a t ) = E π $R t + 1 + γ q π ( S t + 1 , A t + 1 ) ∣ S t = s t , A t = a t$ q_\pi(s_t,a_t) = \mathbb{E}_\pi\left $R_{t+1}+\\gamma q_\\pi(S_{t+1},A_{t+1})\\mid S_t=s_t,A_t=a_t\\right$ qπ(st,at)=Eπ $Rt+1+γqπ(St+1,At+1)∣St=st,At=at$

但 model-free 场景下算不到这个期望,只能拿到一次真实采样 ( s t , a t , r t + 1 , s t + 1 , a t + 1 ) (s_t,a_t,r_{t+1},s_{t+1},a_{t+1}) (st,at,rt+1,st+1,at+1)。于是就用这次采样得到的"一步奖励 + 下一步估计价值 "作为当前 q ( s t , a t ) q(s_t,a_t) q(st,at) 应该靠近的目标------这个目标就叫 TD target:

y t = r t + 1 + γ q ^ ( s t + 1 , a t + 1 , w t ) y_t = r_{t+1}+\gamma\hat{q}(s_{t+1},a_{t+1},w_t) yt=rt+1+γq^(st+1,at+1,wt)

y t y_t yt 不是一个新的真实标签,而是由当前样本和当前 value estimate 构造出来的训练目标。它之所以是"TD"的,是因为它只向前看一步 ,然后用 q ^ ( s t + 1 , a t + 1 , w t ) \hat{q}(s_{t+1},a_{t+1},w_t) q^(st+1,at+1,wt) 做 bootstrapping。

在 tabular Sarsa 中可以直接改表格 entry,但 FA 中 q ( s t , a t ) q(s_t,a_t) q(st,at) 是函数输出,所以要调整参数 w w w 让函数输出更接近 TD target。定义 TD error 并构造平方损失:

δ t = y t − q ^ ( s t , a t , w t ) , L ( w ) = 1 2 δ t 2 , w ← w − α ∇ w L ( w ) \delta_t = y_t - \hat{q}(s_t,a_t,w_t), \qquad L(w)=\frac{1}{2}\delta_t^2, \qquad w\leftarrow w-\alpha\nabla_w L(w) δt=yt−q^(st,at,wt),L(w)=21δt2,w←w−α∇wL(w)

Sarsa with FA 仍然是 on-policy (下一步动作 a t + 1 a_{t+1} at+1 来自当前策略),function approximation 只是把表格换成 q ^ ( s , a , w ) \hat{q}(s,a,w) q^(s,a,w),不改变 on/off-policy 的分类。

Q-learning with FA 同理,但 TD target 用 greedy:

y t = r t + 1 + γ max ⁡ a ∈ A ( s t + 1 ) q ^ ( s t + 1 , a , w t ) y_t = r_{t+1}+\gamma\max_{a\in\mathcal{A}(s_{t+1})}\hat{q}(s_{t+1},a,w_t) yt=rt+1+γa∈A(st+1)maxq^(st+1,a,wt)

这个方法就是 DQN 的前身 。它仍然是 off-policy,核心风险是:Q-learning 本来就是 off-policy,再叠加 function approximation 和 bootstrapping,训练可能变得不稳定。

十五、DQN:两个关键工程技巧

DQN 可以理解为用深度神经网络表示 Q function 的 Q-learning:

q ^ ( s , a , w ) ≈ q ∗ ( s , a ) \hat{q}(s,a,w)\approx q^*(s,a) q^(s,a,w)≈q∗(s,a)

它用 target network q ^ ( ⋅ , ⋅ , w − ) \hat{q}(\cdot,\cdot,w^{-}) q^(⋅,⋅,w−) 估计下一状态的 Q value:

y t = r t + 1 + γ max ⁡ a ∈ A ( s t + 1 ) q ^ ( s t + 1 , a , w − ) y_t = r_{t+1}+\gamma\max_{a\in\mathcal{A}(s_{t+1})}\hat{q}(s_{t+1},a,w^{-}) yt=rt+1+γa∈A(st+1)maxq^(st+1,a,w−)

Q:DQN 为什么需要两个网络?

从概念上说,完全可以只用一个网络 q ^ ( s , a , w ) \hat{q}(s,a,w) q^(s,a,w) 表示 Q value,也用这个网络构造 TD target。问题在于:这样 target 和 prediction 都依赖同一组参数 w w w------一边用梯度下降更新 w w w,一边又用同一个 w w w 生成学习目标,等于让网络追逐一个不断移动的目标 。在深度神经网络中,这种 bootstrapping + function approximation + off-policy 的组合很容易导致训练振荡甚至发散。

因此引入 target network:它和主网络结构相同,也表示 Q value,但参数 w − w^{-} w− 暂时固定 ,只用来计算 TD target;主网络负责被梯度下降更新;每隔一段时间把主网络参数复制给 target network( w − ← w w^{-}\leftarrow w w−←w)。

这两个网络不是在学习两个不同的价值函数 。它们本质上都是对 q ∗ ( s , a ) q^*(s,a) q∗(s,a) 的近似,区别只是主网络是正在学习的估计,target network 是延迟更新的估计。

DQN 的两个关键工程技巧:

Experience replay:把历史经验存到 replay buffer 中,训练时随机采样 mini-batch;
Target network:用一个更新较慢的网络计算 TD target,减少训练目标剧烈变化。

第五部分:Policy Gradient 与 Actor-Critic

十六、从 value-based 到 policy-based

Value-based 方法的基本思路是先学价值函数,然后从价值函数导出策略 。Policy gradient 方法则直接把策略写成参数化函数 π ( a ∣ s , θ ) \pi(a\mid s,\theta) π(a∣s,θ),然后定义一个标量目标 J ( θ ) J(\theta) J(θ),用梯度上升优化:

θ t + 1 = θ t + α ∇ θ J ( θ t ) \theta_{t+1} = \theta_t + \alpha\nabla_\theta J(\theta_t) θt+1=θt+α∇θJ(θt)

Actor-Critic 本质上仍然是 policy gradient 方法,只是它用一个 critic 来估计 value,从而帮助 actor 更新策略。

十七、Actor-Critic 家族

Actor-Critic 是什么? 把 policy-based 和 value-based 结合起来的框架:

Actor :负责表示和更新策略 π ( a ∣ s , θ ) \pi(a\mid s,\theta) π(a∣s,θ);
Critic :负责估计 value(如 v ( s , w ) v(s,w) v(s,w) 或 q ( s , a , w ) q(s,a,w) q(s,a,w)),用来评价 actor 当前动作的好坏。

最简单地说,actor 决定怎么行动,critic 负责给 actor 的行动打分。

Q Actor-Critic(QAC) :最直接的 AC 形式,actor 用 policy gradient 更新,critic 估计 q ( s , a , w ) q(s,a,w) q(s,a,w):

θ t + 1 = θ t + α θ ∇ θ log ⁡ π ( a t ∣ s t , θ t ) q ( s t , a t , w t ) \theta_{t+1} = \theta_t + \alpha_\theta\nabla_\theta\log\pi(a_t\mid s_t,\theta_t)q(s_t,a_t,w_t) θt+1=θt+αθ∇θlogπ(at∣st,θt)q(st,at,wt)

A2C(Advantage Actor-Critic) :核心是把 Q value 换成 advantage:

A π ( s , a ) = q π ( s , a ) − v π ( s ) A_\pi(s,a) = q_\pi(s,a) - v_\pi(s) Aπ(s,a)=qπ(s,a)−vπ(s)

Advantage 表示:在状态 s s s 下,动作 a a a 比当前策略的平均水平好多少。实际算法中 advantage 常用 TD error 近似:

δ t = r t + 1 + γ v ( s t + 1 , w t ) − v ( s t , w t ) , θ t + 1 = θ t + α θ δ t ∇ θ log ⁡ π ( a t ∣ s t , θ t ) \delta_t = r_{t+1}+\gamma v(s_{t+1},w_t) - v(s_t,w_t), \qquad \theta_{t+1} = \theta_t + \alpha_\theta\delta_t\nabla_\theta\log\pi(a_t\mid s_t,\theta_t) δt=rt+1+γv(st+1,wt)−v(st,wt),θt+1=θt+αθδt∇θlogπ(at∣st,θt)

A2C 的好处是使用 baseline v π ( s ) v_\pi(s) vπ(s) 降低策略梯度估计的方差。

Off-policy Actor-Critic :普通 policy gradient 通常是 on-policy(梯度期望里的动作需来自当前策略)。Off-policy AC 允许 β \beta β 和 π \pi π 不同,为修正采样分布不一致,常用重要性采样权重:

π ( a t ∣ s t , θ ) β ( a t ∣ s t ) \frac{\pi(a_t\mid s_t,\theta)}{\beta(a_t\mid s_t)} β(at∣st)π(at∣st,θ)

直观上,如果某个动作在目标策略下更可能出现、但在行为策略下较少出现,就提高它的权重;反之降低。

DPG(Deterministic Policy Gradient) :前面的 policy gradient 通常用随机策略,DPG 使用确定性策略 a = μ ( s , θ ) a=\mu(s,\theta) a=μ(s,θ),适合连续动作空间(连续动作下对所有动作求分布再采样比较麻烦)。DDPG 可以看成 DPG 的深度学习版本:actor 和 critic 都用神经网络,并配合 replay buffer 和 target network。
#mermaid-svg-8oUoROpmQoJDYl9R{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-8oUoROpmQoJDYl9R .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-8oUoROpmQoJDYl9R .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-8oUoROpmQoJDYl9R .error-icon{fill:#552222;}#mermaid-svg-8oUoROpmQoJDYl9R .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-8oUoROpmQoJDYl9R .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-8oUoROpmQoJDYl9R .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-8oUoROpmQoJDYl9R .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-8oUoROpmQoJDYl9R .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-8oUoROpmQoJDYl9R .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-8oUoROpmQoJDYl9R .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-8oUoROpmQoJDYl9R .marker{fill:#333333;stroke:#333333;}#mermaid-svg-8oUoROpmQoJDYl9R .marker.cross{stroke:#333333;}#mermaid-svg-8oUoROpmQoJDYl9R svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-8oUoROpmQoJDYl9R p{margin:0;}#mermaid-svg-8oUoROpmQoJDYl9R .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-8oUoROpmQoJDYl9R .cluster-label text{fill:#333;}#mermaid-svg-8oUoROpmQoJDYl9R .cluster-label span{color:#333;}#mermaid-svg-8oUoROpmQoJDYl9R .cluster-label span p{background-color:transparent;}#mermaid-svg-8oUoROpmQoJDYl9R .label text,#mermaid-svg-8oUoROpmQoJDYl9R span{fill:#333;color:#333;}#mermaid-svg-8oUoROpmQoJDYl9R .node rect,#mermaid-svg-8oUoROpmQoJDYl9R .node circle,#mermaid-svg-8oUoROpmQoJDYl9R .node ellipse,#mermaid-svg-8oUoROpmQoJDYl9R .node polygon,#mermaid-svg-8oUoROpmQoJDYl9R .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-8oUoROpmQoJDYl9R .rough-node .label text,#mermaid-svg-8oUoROpmQoJDYl9R .node .label text,#mermaid-svg-8oUoROpmQoJDYl9R .image-shape .label,#mermaid-svg-8oUoROpmQoJDYl9R .icon-shape .label{text-anchor:middle;}#mermaid-svg-8oUoROpmQoJDYl9R .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-8oUoROpmQoJDYl9R .rough-node .label,#mermaid-svg-8oUoROpmQoJDYl9R .node .label,#mermaid-svg-8oUoROpmQoJDYl9R .image-shape .label,#mermaid-svg-8oUoROpmQoJDYl9R .icon-shape .label{text-align:center;}#mermaid-svg-8oUoROpmQoJDYl9R .node.clickable{cursor:pointer;}#mermaid-svg-8oUoROpmQoJDYl9R .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-8oUoROpmQoJDYl9R .arrowheadPath{fill:#333333;}#mermaid-svg-8oUoROpmQoJDYl9R .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-8oUoROpmQoJDYl9R .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-8oUoROpmQoJDYl9R .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-8oUoROpmQoJDYl9R .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-8oUoROpmQoJDYl9R .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-8oUoROpmQoJDYl9R .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-8oUoROpmQoJDYl9R .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-8oUoROpmQoJDYl9R .cluster text{fill:#333;}#mermaid-svg-8oUoROpmQoJDYl9R .cluster span{color:#333;}#mermaid-svg-8oUoROpmQoJDYl9R div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-8oUoROpmQoJDYl9R .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-8oUoROpmQoJDYl9R rect.text{fill:none;stroke-width:0;}#mermaid-svg-8oUoROpmQoJDYl9R .icon-shape,#mermaid-svg-8oUoROpmQoJDYl9R .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-8oUoROpmQoJDYl9R .icon-shape p,#mermaid-svg-8oUoROpmQoJDYl9R .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-8oUoROpmQoJDYl9R .icon-shape .label rect,#mermaid-svg-8oUoROpmQoJDYl9R .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-8oUoROpmQoJDYl9R .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-8oUoROpmQoJDYl9R .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-8oUoROpmQoJDYl9R :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} Policy Gradient

直接优化 π(a|s,θ)
Actor-Critic

加一个 critic 估计 value
QAC

critic 估 q, 直接用 q
A2C

用 advantage A=q-v

baseline 降方差
Off-policy AC

加重要性采样权重
DPG/DDPG

确定性策略, 适合连续动作
PPO / GRPO 等

现代 LLM RL 方法的基础

第六部分:通用工具与思想

这部分是"General 算法和思想",本身不全是 RL 专属,但会反复出现在 RL 的推导中。

十八、Monte Carlo estimation

用采样平均估计期望:

E $X$ ≈ 1 N ∑ i = 1 N x i \mathbb{E} $X$ \approx\frac{1}{N}\sum_{i=1}^{N}x_i E $X$ ≈N1i=1∑Nxi

它本身不是 RL 专属算法,但 RL 中很多对象都是期望(value、return、policy gradient),所以 Monte Carlo 思想会反复出现。

十九、Robbins-Monro / Stochastic Approximation

这是理解 TD learning 的关键数学工具。它解决这样一类问题:想求方程的根 g ( w ) = 0 g(w)=0 g(w)=0,但很多时候不能直接计算 g ( w t ) g(w_t) g(wt)(Model Free) ,第 t t t 步只能通过一次随机采样得到 noisy observation g ~ ( w t , ξ t ) \tilde{g}(w_t,\xi_t) g~(wt,ξt)。

这里最容易混淆的是 ξ t \xi_t ξt 到底是什么 ------它不是参数 w t w_t wt,也不是 g ( w t ) g(w_t) g(wt) 本身,而是第 t t t 次随机采样得到的信息(一个数据点、一个 mini-batch,或 RL 中一次环境交互得到的 transition):

w t w_t wt:当前算法手里的参数,通常可看成已确定的量;
g ( w t ) g(w_t) g(wt):在 w t w_t wt 处真正想知道的确定性函数值,但通常算不到;
ξ t \xi_t ξt:第 t t t 次采样带来的随机信息;
g ~ ( w t , ξ t ) \tilde{g}(w_t,\xi_t) g~(wt,ξt):用这次随机信息构造出来的 g ( w t ) g(w_t) g(wt) 的 noisy observation。

关键假设是这个 noisy observation 在条件期望意义下等于真正的 g ( w t ) g(w_t) g(wt):

E $g \~ ( w t , ξ t ) ∣ w t$ = g ( w t ) \mathbb{E}\left $\\tilde{g}(w_t,\\xi_t)\\mid w_t\\right$ = g(w_t) E $g\~(wt,ξt)∣wt$ =g(wt)

更新形式是 w t + 1 = w t − α t g ~ ( w t , ξ t ) w_{t+1} = w_t - \alpha_t\tilde{g}(w_t,\xi_t) wt+1=wt−αtg~(wt,ξt)。

直觉理解 :如果我们能直接计算 g ( w t ) g(w_t) g(wt),做迭代 w t + 1 = w t − α t g ( w t ) w_{t+1}=w_t-\alpha_t g(w_t) wt+1=wt−αtg(wt),若 g ( w t ) = 0 g(w_t)=0 g(wt)=0 就已经找到了根。但现在 g ( w t ) g(w_t) g(wt) 算不到,于是用 g ~ ( w t , ξ t ) \tilde{g}(w_t,\xi_t) g~(wt,ξt) 代替它。也就是说,stochastic approximation 是在用"带噪声的观测"逼近一个确定性的求根过程。

19.1 三类收敛条件

把 noisy observation 写成真实值加观测误差 g ~ ( w t , ξ t ) = g ( w t ) + η t \tilde{g}(w_t,\xi_t)=g(w_t)+\eta_t g~(wt,ξt)=g(wt)+ηt,设 H t \mathcal{H}_t Ht 为第 t t t 步之前的历史信息:

条件 1: g g g 的方向要稳定,并且根要是唯一的。

一维情形下,常见条件是存在 c 1 , c 2 > 0 c_1,c_2>0 c1,c2>0 使得 0 < c 1 ≤ ∇ w g ( w ) ≤ c 2 0<c_1\le\nabla_w g(w)\le c_2 0<c1≤∇wg(w)≤c2。单调性保证根不会有多个;正的下界保证算法在根附近仍有明确修正方向;上界避免函数变化过于剧烈。

条件 2:step size 要逐渐变小,但不能变得太快。

∑ t = 0 ∞ α t = ∞ , ∑ t = 0 ∞ α t 2 < ∞ \sum_{t=0}^{\infty}\alpha_t=\infty, \qquad \sum_{t=0}^{\infty}\alpha_t^2<\infty t=0∑∞αt=∞,t=0∑∞αt2<∞

∑ α t = ∞ \sum\alpha_t=\infty ∑αt=∞ 表示总步长不能太小,否则可能还没走到根附近就停住; ∑ α t 2 < ∞ \sum\alpha_t^2<\infty ∑αt2<∞ 表示步长要足够快地变小,使随机噪声的累计影响可控。典型选择是 α t = 1 / t \alpha_t=1/t αt=1/t。

条件 3:观测误差不能有系统性偏差,并且方差要有限。

E $η t ∣ H t$ = 0 , E $η t 2 ∣ H t$ < ∞ \mathbb{E}\left $\\eta_t\\mid\\mathcal{H}_t\\right$ =0, \qquad \mathbb{E}\left $\\eta_t\^2\\mid\\mathcal{H}_t\\right$ <\infty E $ηt∣Ht$ =0,E $ηt2∣Ht$ <∞

在这些条件下,Robbins-Monro 迭代会以概率 1 收敛 到 g ( w ) = 0 g(w)=0 g(w)=0 的根 w ∗ w^* w∗。

19.2 应用一:求期望的值

想求 μ = E $X$ \mu=\mathbb{E} $X$ μ=E $X$ ,令 w w w 表示对 μ \mu μ 的估计,则问题写成 g ( w ) = w − E $X$ = 0 g(w)=w-\mathbb{E} $X$ =0 g(w)=w−E $X$ =0。每次只拿到一个样本 X t X_t Xt,则 ξ t = X t \xi_t=X_t ξt=Xt,构造:

g ~ ( w t , X t ) = w t − X t \tilde{g}(w_t,X_t) = w_t-X_t g~(wt,Xt)=wt−Xt

它确实是 g ( w t ) g(w_t) g(wt) 的无偏观测。代入更新得:

w t + 1 = w t + α t ( X t − w t ) w_{t+1} = w_t+\alpha_t(X_t-w_t) wt+1=wt+αt(Xt−wt)

这说明求期望可以转化成求根问题,每次样本 X t X_t Xt 就是随机观测 ξ t \xi_t ξt。

19.3 应用二:TD learning 是 stochastic approximation 的一个实例

固定策略 π \pi π 和状态 s s s,state value 满足 v π ( s ) = E π $R t + 1 + γ v π ( S t + 1 ) ∣ S t = s$ v_\pi(s)=\mathbb{E}_\pi $R_{t+1}+\\gamma v_\\pi(S_{t+1})\\mid S_t=s$ vπ(s)=Eπ $Rt+1+γvπ(St+1)∣St=s$ 。把右边移到左边就得到求根问题。把当前 value estimate 记为 w w w,定义:

g s ( w ) = w ( s ) − E π $R t + 1 + γ w ( S t + 1 ) ∣ S t = s$ g_s(w) = w(s) - \mathbb{E}_\pi\left $R_{t+1}+\\gamma w(S_{t+1})\\mid S_t=s\\right$ gs(w)=w(s)−Eπ $Rt+1+γw(St+1)∣St=s$

在 model-free RL 中这个期望算不到,一次环境交互只给出一个 transition ξ t = ( s t , r t + 1 , s t + 1 ) \xi_t=(s_t,r_{t+1},s_{t+1}) ξt=(st,rt+1,st+1)。于是用样本近似,得到 noisy observation:

g ~ ( w t , ξ t ) ( s t ) = w t ( s t ) − $r t + 1 + γ w t ( s t + 1 )$ \tilde{g}(w_t,\xi_t)(s_t) = w_t(s_t)-\left $r_{t+1}+\\gamma w_t(s_{t+1})\\right$ g~(wt,ξt)(st)=wt(st)− $rt+1+γwt(st+1)$

代入 Robbins-Monro 更新,就得到 TD(0) 的形式:

w t + 1 ( s t ) = w t ( s t ) + α t $r t + 1 + γ w t ( s t + 1 ) - w t ( s t )$ w_{t+1}(s_t) = w_t(s_t)+\alpha_t\left $r_{t+1}+\\gamma w_t(s_{t+1})-w_t(s_t)\\right$ wt+1(st)=wt(st)+αt $rt+1+γwt(st+1)-wt(st)$

方括号里的量就是 TD error。从 stochastic approximation 的角度看,TD learning 做的事情就是:把每个状态上的 value equation 写成 g s ( w ) = 0 g_s(w)=0 gs(w)=0,再用一次次随机 transition 构造 g ~ \tilde{g} g~,用 noisy observation 逼近这些方程的根。
#mermaid-svg-B4fne6uvISvODNDC{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-B4fne6uvISvODNDC .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-B4fne6uvISvODNDC .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-B4fne6uvISvODNDC .error-icon{fill:#552222;}#mermaid-svg-B4fne6uvISvODNDC .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-B4fne6uvISvODNDC .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-B4fne6uvISvODNDC .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-B4fne6uvISvODNDC .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-B4fne6uvISvODNDC .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-B4fne6uvISvODNDC .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-B4fne6uvISvODNDC .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-B4fne6uvISvODNDC .marker{fill:#333333;stroke:#333333;}#mermaid-svg-B4fne6uvISvODNDC .marker.cross{stroke:#333333;}#mermaid-svg-B4fne6uvISvODNDC svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-B4fne6uvISvODNDC p{margin:0;}#mermaid-svg-B4fne6uvISvODNDC .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-B4fne6uvISvODNDC .cluster-label text{fill:#333;}#mermaid-svg-B4fne6uvISvODNDC .cluster-label span{color:#333;}#mermaid-svg-B4fne6uvISvODNDC .cluster-label span p{background-color:transparent;}#mermaid-svg-B4fne6uvISvODNDC .label text,#mermaid-svg-B4fne6uvISvODNDC span{fill:#333;color:#333;}#mermaid-svg-B4fne6uvISvODNDC .node rect,#mermaid-svg-B4fne6uvISvODNDC .node circle,#mermaid-svg-B4fne6uvISvODNDC .node ellipse,#mermaid-svg-B4fne6uvISvODNDC .node polygon,#mermaid-svg-B4fne6uvISvODNDC .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-B4fne6uvISvODNDC .rough-node .label text,#mermaid-svg-B4fne6uvISvODNDC .node .label text,#mermaid-svg-B4fne6uvISvODNDC .image-shape .label,#mermaid-svg-B4fne6uvISvODNDC .icon-shape .label{text-anchor:middle;}#mermaid-svg-B4fne6uvISvODNDC .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-B4fne6uvISvODNDC .rough-node .label,#mermaid-svg-B4fne6uvISvODNDC .node .label,#mermaid-svg-B4fne6uvISvODNDC .image-shape .label,#mermaid-svg-B4fne6uvISvODNDC .icon-shape .label{text-align:center;}#mermaid-svg-B4fne6uvISvODNDC .node.clickable{cursor:pointer;}#mermaid-svg-B4fne6uvISvODNDC .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-B4fne6uvISvODNDC .arrowheadPath{fill:#333333;}#mermaid-svg-B4fne6uvISvODNDC .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-B4fne6uvISvODNDC .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-B4fne6uvISvODNDC .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-B4fne6uvISvODNDC .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-B4fne6uvISvODNDC .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-B4fne6uvISvODNDC .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-B4fne6uvISvODNDC .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-B4fne6uvISvODNDC .cluster text{fill:#333;}#mermaid-svg-B4fne6uvISvODNDC .cluster span{color:#333;}#mermaid-svg-B4fne6uvISvODNDC div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-B4fne6uvISvODNDC .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-B4fne6uvISvODNDC rect.text{fill:none;stroke-width:0;}#mermaid-svg-B4fne6uvISvODNDC .icon-shape,#mermaid-svg-B4fne6uvISvODNDC .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-B4fne6uvISvODNDC .icon-shape p,#mermaid-svg-B4fne6uvISvODNDC .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-B4fne6uvISvODNDC .icon-shape .label rect,#mermaid-svg-B4fne6uvISvODNDC .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-B4fne6uvISvODNDC .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-B4fne6uvISvODNDC .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-B4fne6uvISvODNDC :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 确定性求根

w ← w - α·g(w)

(算不到 g)
Stochastic Approximation

w ← w - α·ĝ(w,ξ)

(用一次采样代替)
求均值

ĝ = w - X_t

→ w ← w + α(X_t - w)
TD learning

ĝ = w(s_t) - $r+γw(s_{t+1})$

→ TD(0) 更新
统一形式:

new = old + α $target - old$

二十、SGD / BGD / MBGD 与重要性采样

三种梯度下降都是优化算法,用来最小化目标函数:

BGD(Batch GD):每次用全部数据估计梯度;
SGD(Stochastic GD):每次用一个样本估计梯度;
MBGD(Mini-batch GD):每次用一小批样本估计梯度。

深度学习里最常见的是 mini-batch SGD 及其变体。RL 中一旦引入 function approximation,尤其是神经网络,就会自然用到这些优化算法。

重要性采样(Importance sampling):用一种分布下的样本估计另一种分布下的期望:

E x ∼ p 0 $f ( x )$ = E x ∼ p 1 $p 0 ( x ) p 1 ( x ) f ( x )$ \mathbb{E}{x\sim p_0} $f(x)$ = \mathbb{E}{x\sim p_1}\left $\\frac{p_0(x)}{p_1(x)}f(x)\\right$ Ex∼p0 $f(x)$ =Ex∼p1 $p1(x)p0(x)f(x)$

其中 p 0 ( x ) p 1 ( x ) \frac{p_0(x)}{p_1(x)} p1(x)p0(x) 就是 importance weight。在 RL 中常用于 off-policy 学习:数据来自 behavior policy,但希望估计 target policy 的目标。

第七部分:概念总结

二十一、七组核心分类

21.1 Model-based 与 Model-free

Model-based :需要或显式学习环境模型 p ( s ′ , r ∣ s , a ) p(s',r\mid s,a) p(s′,r∣s,a)。Value iteration 和 policy iteration 是典型;
Model-free:不需要显式知道环境模型,直接从经验样本中学习 value 或 policy。MC、TD、Sarsa、Q-learning、policy gradient、actor-critic 都属于这类。

21.2 On-policy 与 Off-policy

On-policy:behavior policy 和 target policy 是同一个策略。MC control、Sarsa、A2C 通常是 on-policy;
Off-policy:二者可以不同。Q-learning 是经典 off-policy(用探索策略采样,学 greedy target policy)。

这个分类和是否使用 function approximation 没有直接关系。

21.3 Online 与 Offline

Online:智能体可以边和环境交互边更新,如 TD、Sarsa、Q-learning;
Offline:需要先收集数据,再用固定数据集学习,或至少等一整条 episode 完成后再更新。MC 通常更接近 offline。

注意:现代语境里的 offline RL 往往特指"只用已有数据集训练,不再和环境交互"。这和课程中"MC 必须等 episode 结束"的 offline 说法不是完全同一个层次,但核心区别都是"是否边采样边更新"。

21.4 Online/Offline 与 On-policy/Off-policy 的关系

这是两组不同的分类,回答的问题不同:

Online/offline 关心数据如何产生:训练过程中是否还能继续和环境交互、继续采样新数据;
On-policy/off-policy 关心数据由谁产生:behavior policy 和正在学习的 target policy 是否相同。

因此 off-policy 不等于 offline。 Q-learning 和 DQN 通常是 off-policy,但它们可以是 online 的:一边用 ε-greedy behavior policy 和环境交互,一边学习 greedy target policy。

反过来,offline RL 通常需要 off-policy 思想 ------因为数据集已提前固定,训练时的当前策略 π \pi π 已不能再决定数据分布;数据来自某个历史 behavior policy β \beta β,而我们希望得到一个新的、更好的 target policy π \pi π,这时 β \beta β 和 π \pi π 通常不同,问题天然带有 off-policy 性质。

数据设置	策略关系	典型例子
Online + On-policy	边采样边更新,数据来自当前策略	Sarsa、A2C、PPO 类方法
Online + Off-policy	边采样边更新,但 behavior/target policy 不同	Q-learning、DQN
Offline + Off-policy	数据集固定,训练目标策略通常不同于数据来源策略	Offline Q-learning、CQL、IQL
Offline + On-policy	数据固定且来自同一目标策略,更像 policy evaluation	一般没有这种算法

21.5 Behavior policy 与 Target policy

前者用来产生数据,后者是算法真正想学习或评估的策略。on-policy 中二者相同,off-policy 中二者不同。

21.6 Exploration 与 Exploitation

Exploration:探索还不确定的动作,以免错过潜在更优选择;
Exploitation:利用当前已经知道的高价值动作。

ε-greedy 是最简单的探索机制。Policy gradient 和 actor-critic 中的随机策略也天然带有探索能力,因为 π ( a ∣ s , θ ) \pi(a\mid s,\theta) π(a∣s,θ) 本身是一个动作分布。

21.7 Episodic Task 与 Continuing Task

Episodic:有明确终止状态,一条 episode 会结束(游戏关卡、一次完整对话);
Continuing :没有自然终止状态,智能体会持续和环境交互。TD 方法适合 continuing task,因为它不需要等完整 episode 结束。

二十二、统一视角:从"期望"和"样本"理解 RL 算法

RL 算法看起来很杂,但很多都可以用同一个视角理解:

先问:这个算法真正想估计的期望是什么? (尤其想一下这个期望到底是哪几个随机变量的联合期望?要估计它,样本就要来自它的联合分布)
再问:为了估计这个期望,它实际需要什么样的样本?

很多 RL 对象本质上都是期望:value 是 return 的期望,Q value 是给定 state-action 后 return 的期望,policy gradient 是某个随机梯度估计的期望。算法的差别,往往不在于"是不是在求期望",而在于它选择了什么样的期望形式,以及用什么样的样本去近似这个期望。

统一模板:

target = E $random quantity$ \text{target} = \mathbb{E}\left $\\text{random quantity}\\right$ target=E $random quantity$

实际训练时通常拿不到这个期望,只能采样一个或一批样本,构造 sampled target,然后让当前 estimate 靠近它。
#mermaid-svg-11QJEov8bK7msD44{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-11QJEov8bK7msD44 .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-11QJEov8bK7msD44 .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-11QJEov8bK7msD44 .error-icon{fill:#552222;}#mermaid-svg-11QJEov8bK7msD44 .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-11QJEov8bK7msD44 .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-11QJEov8bK7msD44 .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-11QJEov8bK7msD44 .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-11QJEov8bK7msD44 .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-11QJEov8bK7msD44 .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-11QJEov8bK7msD44 .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-11QJEov8bK7msD44 .marker{fill:#333333;stroke:#333333;}#mermaid-svg-11QJEov8bK7msD44 .marker.cross{stroke:#333333;}#mermaid-svg-11QJEov8bK7msD44 svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-11QJEov8bK7msD44 p{margin:0;}#mermaid-svg-11QJEov8bK7msD44 .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-11QJEov8bK7msD44 .cluster-label text{fill:#333;}#mermaid-svg-11QJEov8bK7msD44 .cluster-label span{color:#333;}#mermaid-svg-11QJEov8bK7msD44 .cluster-label span p{background-color:transparent;}#mermaid-svg-11QJEov8bK7msD44 .label text,#mermaid-svg-11QJEov8bK7msD44 span{fill:#333;color:#333;}#mermaid-svg-11QJEov8bK7msD44 .node rect,#mermaid-svg-11QJEov8bK7msD44 .node circle,#mermaid-svg-11QJEov8bK7msD44 .node ellipse,#mermaid-svg-11QJEov8bK7msD44 .node polygon,#mermaid-svg-11QJEov8bK7msD44 .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-11QJEov8bK7msD44 .rough-node .label text,#mermaid-svg-11QJEov8bK7msD44 .node .label text,#mermaid-svg-11QJEov8bK7msD44 .image-shape .label,#mermaid-svg-11QJEov8bK7msD44 .icon-shape .label{text-anchor:middle;}#mermaid-svg-11QJEov8bK7msD44 .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-11QJEov8bK7msD44 .rough-node .label,#mermaid-svg-11QJEov8bK7msD44 .node .label,#mermaid-svg-11QJEov8bK7msD44 .image-shape .label,#mermaid-svg-11QJEov8bK7msD44 .icon-shape .label{text-align:center;}#mermaid-svg-11QJEov8bK7msD44 .node.clickable{cursor:pointer;}#mermaid-svg-11QJEov8bK7msD44 .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-11QJEov8bK7msD44 .arrowheadPath{fill:#333333;}#mermaid-svg-11QJEov8bK7msD44 .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-11QJEov8bK7msD44 .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-11QJEov8bK7msD44 .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-11QJEov8bK7msD44 .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-11QJEov8bK7msD44 .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-11QJEov8bK7msD44 .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-11QJEov8bK7msD44 .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-11QJEov8bK7msD44 .cluster text{fill:#333;}#mermaid-svg-11QJEov8bK7msD44 .cluster span{color:#333;}#mermaid-svg-11QJEov8bK7msD44 div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-11QJEov8bK7msD44 .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-11QJEov8bK7msD44 rect.text{fill:none;stroke-width:0;}#mermaid-svg-11QJEov8bK7msD44 .icon-shape,#mermaid-svg-11QJEov8bK7msD44 .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-11QJEov8bK7msD44 .icon-shape p,#mermaid-svg-11QJEov8bK7msD44 .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-11QJEov8bK7msD44 .icon-shape .label rect,#mermaid-svg-11QJEov8bK7msD44 .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-11QJEov8bK7msD44 .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-11QJEov8bK7msD44 .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-11QJEov8bK7msD44 :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 统一视角

target = E $random quantity$
On/Off-policy:

样本来自哪个策略?
Online/Offline:

训练中继续采 or 提前固定?
MC / TD / n-step / GAE:

用多长的轨迹样本?
Bootstrapping:

样本目标里是否用当前估计补未来?
对齐不同算法的差别

用这个视角对齐典型算法:

算法	想估计的期望	实际需要的样本	样本目标/估计量
Monte Carlo value	v π ( s ) = E π $G t ∣ S t = s$ v_\pi(s)=\mathbb{E}_\pi $G_t\\mid S_t=s$ vπ(s)=Eπ $Gt∣St=s$	从 s s s 开始的一整条 episode	完整 return G t G_t Gt
TD(0)	v π ( s ) = E π $R t + 1 + γ v π ( S t + 1 ) ∣ S t = s$ v_\pi(s)=\mathbb{E}_\pi $R_{t+1}+\\gamma v_\\pi(S_{t+1})\\mid S_t=s$ vπ(s)=Eπ $Rt+1+γvπ(St+1)∣St=s$	一步 transition	r t + 1 + γ v t ( s t + 1 ) r_{t+1}+\gamma v_t(s_{t+1}) rt+1+γvt(st+1)
Sarsa	q π ( s , a ) = E π $R t + 1 + γ q π ( S t + 1 , A t + 1 ) ∣ S t = s , A t = a$ q_\pi(s,a)=\mathbb{E}_\pi $R_{t+1}+\\gamma q_\\pi(S_{t+1},A_{t+1})\\mid S_t=s,A_t=a$ qπ(s,a)=Eπ $Rt+1+γqπ(St+1,At+1)∣St=s,At=a$	( s t , a t , r t + 1 , s t + 1 , a t + 1 ) (s_t,a_t,r_{t+1},s_{t+1},a_{t+1}) (st,at,rt+1,st+1,at+1)	r t + 1 + γ q t ( s t + 1 , a t + 1 ) r_{t+1}+\gamma q_t(s_{t+1},a_{t+1}) rt+1+γqt(st+1,at+1)
Q-learning	q ∗ ( s , a ) = E $R t + 1 + γ max a ' q * ( S t + 1 , a ' ) ∣ S t = s , A t = a$ q^(s,a)=\mathbb{E} $R_{t+1}+\\gamma\\max_{a'}q\^\(S_{t+1},a')\\mid S_t=s,A_t=a$ q∗(s,a)=E $Rt+1+γmaxa'q*(St+1,a')∣St=s,At=a$	( s t , a t , r t + 1 , s t + 1 ) (s_t,a_t,r_{t+1},s_{t+1}) (st,at,rt+1,st+1)	r t + 1 + γ max ⁡ a ′ q t ( s t + 1 , a ′ ) r_{t+1}+\gamma\max_{a'}q_t(s_{t+1},a') rt+1+γmaxa′qt(st+1,a′)
DQN	Q-learning 的 Bellman optimality target	replay buffer 中的 transition mini-batch	r + γ max ⁡ a q ^ ( s ′ , a , w − ) r+\gamma\max_a\hat{q}(s',a,w^{-}) r+γmaxaq^(s′,a,w−)
Policy gradient	∇ θ J ( θ ) = E $\nabla θ log π θ ( A t ∣ S t ) G t$ \nabla_\theta J(\theta)=\mathbb{E} $\\nabla_\\theta\\log\\pi_\\theta(A_t\\mid S_t)G_t$ ∇θJ(θ)=E $\nablaθlogπθ(At∣St)Gt$	on-policy trajectory	likelihood-ratio gradient sample
Actor-Critic	policy gradient 中的 return/advantage 期望	transition 或短 rollout	TD error / advantage estimate
GAE	advantage 的加权多步估计	一段 rollout	多个 TD error 的折扣加权和

这个表格也解释了为什么 RL 算法的采样方式会不同 :MC 需要完整 episode(直接用完整 return);TD(0) 只需一步 transition(把期望写成一步 reward 加下一状态 value);Sarsa 需要额外采样 a t + 1 a_{t+1} at+1(target 里有下一步动作);Q-learning 不需要采样 target action(直接对下一状态 action value 取 max)。

理解一个 RL 算法时,一个很好的检查顺序:

它要估计哪个期望?
这个期望条件在什么变量上?
为了构造样本估计,需要采样哪些随机变量?
这个 sampled target 有没有 bootstrapping?

二十三、RL 中的样本构造:四个层次

RL 里很多术语都和"样本长什么样"有关。最核心的对象是 trajectory,其他很多词都可以看成 trajectory 的不同切片、不同用途,或者生成 trajectory 的过程。

术语	含义
Trajectory	一整条交互序列 τ = ( s 0 , a 0 , r 1 , s 1 , a 1 , r 2 , ... , s T ) \tau=(s_0,a_0,r_1,s_1,a_1,r_2,\ldots,s_T) τ=(s0,a0,r1,s1,a1,r2,...,sT)
Episode	有明确开始和结束的一条完整 trajectory(一局游戏、一次完整对话)
Transition	trajectory 中的一步 ( s t , a t , r t + 1 , s t + 1 ) (s_t,a_t,r_{t+1},s_{t+1}) (st,at,rt+1,st+1),是很多 value-based 方法的基本样本单位
Rollout	更强调"生成样本的过程"------让当前策略在环境里跑一段时间采样出 trajectory

text 复制代码

Rollout（采样过程）
    ↓
Trajectory（完整或部分交互序列）
    ↓
Episode（有终止状态的一整条 trajectory）
    ↓
Transition（trajectory 中的一步）

Replay buffer 是保存样本的数据容器,可以保存 transition,也可以保存整条 trajectory 或短 rollout。DQN 这类 off-policy 方法常用它。

在 LLM 语境中也常说 rollout:给定 prompt,让模型根据当前策略生成一段回答,这也是一次 rollout。生成出来的 token 序列就可以看成 trajectory。

不同算法需要不同粒度的样本:TD 和 Q-learning 通常只需 transition;Sarsa 需要多一个下一步动作;MC 和 policy gradient 往往需要一整条 trajectory 或 episode;GAE 和 actor-critic 常用一段 rollout 构造 advantage estimate。

二十四、Bootstrapping 与 Non-bootstrapping

Bootstrapping 指更新目标里使用了当前 value estimate。 例如 TD target R t + 1 + γ v t ( S t + 1 ) R_{t+1}+\gamma v_t(S_{t+1}) Rt+1+γvt(St+1) 里的 v t ( S t + 1 ) v_t(S_{t+1}) vt(St+1) 就是当前估计值。

更准确地说,bootstrapping 不是"截断轨迹"本身,而是"截断之后用当前估计值补上未来部分"。

完整 return: G t = R t + 1 + γ R t + 2 + γ 2 R t + 3 + ⋯ G_t = R_{t+1}+\gamma R_{t+2}+\gamma^2 R_{t+3}+\cdots Gt=Rt+1+γRt+2+γ2Rt+3+⋯
TD(0):一步后截断,用 v t ( S t + 1 ) v_t(S_{t+1}) vt(St+1) 代替后面的未来回报 → R t + 1 + γ v t ( S t + 1 ) R_{t+1}+\gamma v_t(S_{t+1}) Rt+1+γvt(St+1) → 这是 bootstrapping
只取前 n n n 步奖励、直接忽略后面: R t + 1 + γ R t + 2 + ⋯ + γ n − 1 R t + n R_{t+1}+\gamma R_{t+2}+\cdots+\gamma^{n-1}R_{t+n} Rt+1+γRt+2+⋯+γn−1Rt+n → 这只是 truncated return,不是 bootstrapping(没用当前估计值)
截断后接上当前估计值: R t + 1 + ⋯ + γ n − 1 R t + n + γ n v t ( S t + n ) R_{t+1}+\cdots+\gamma^{n-1}R_{t+n}+\gamma^n v_t(S_{t+n}) Rt+1+⋯+γn−1Rt+n+γnvt(St+n) → 这才是 n-step bootstrapping

方法	是否截断轨迹	是否 bootstrapping
Monte Carlo	否,等完整 episode	否
TD(0)	是,一步截断	是
n-step TD	是, n n n 步截断	是(后面接 v t ( S t + n ) v_t(S_{t+n}) vt(St+n))
Truncated return without value estimate	是	否
GAE / λ-return	混合多个 n-step return	通常是
Q-learning / DQN	是,一步截断	是

一个更准确的说法是:很多 bootstrapping 方法都会截断轨迹,但不是所有截断轨迹的方法都是 bootstrapping。只有当截断后用当前 value estimate 或 Q estimate 去补未来部分时,才叫 bootstrapping。

二十五、Tabular / Value-based / Policy-based 等其他分类

Tabular vs Function Approximation:tabular 把每个状态或 state-action pair 的 value 单独存表,清晰稳定但无法扩展;FA 用参数化函数表示 value 或 policy,可泛化到没见过的状态,但引入优化不稳定性。

Value-based / Policy-based / Actor-Critic:

Value-based:先学 value,再由 value 导出策略(Value iteration、Q-learning、DQN);
Policy-based:直接优化参数化策略(Policy gradient、REINFORCE);
Actor-Critic:二者结合,actor 学策略,critic 学 value,用 value 信号帮助 policy update。

二十六、常见算法粗略分类总表

算法	是否需要模型	On-policy / Off-policy	Online / Offline	是否 bootstrapping
Value iteration	Model-based	不强调	Offline planning	是
Policy iteration	Model-based	不强调	Offline planning	是
Monte Carlo control	Model-free	通常 on-policy	通常 offline	否
TD state value learning	Model-free	On-policy evaluation	Online	是
Sarsa	Model-free	On-policy	Online	是
Q-learning	Model-free	Off-policy	Online	是
DQN	Model-free	Off-policy	Online / replay buffer	是
REINFORCE	Model-free	On-policy	通常按 episode 更新	否
Actor-Critic / A2C	Model-free	通常 on-policy	Online	是
Off-policy Actor-Critic	Model-free	Off-policy	Online / replay buffer	是

总结

主题	一句话要点
记号	严格区分随机变量( S t , A t , R t + 1 S_t,A_t,R_{t+1} St,At,Rt+1)与取值( s , a , r s,a,r s,a,r);奖励角标是 t + 1 t+1 t+1
MDP	( S , A , p , r , γ ) (\mathcal{S},\mathcal{A},p,r,\gamma) (S,A,p,r,γ);Markov 性 = 未来只依赖当前 (S,A)
轨迹概率	两类随机性:策略 π ( a ∣ s ) \pi(a\mid s) π(a∣s) + 环境 p ( s ′ , r ∣ s , a ) p(s',r\mid s,a) p(s′,r∣s,a)
Return	G t = R t + 1 + γ G t + 1 G_t=R_{t+1}+\gamma G_{t+1} Gt=Rt+1+γGt+1,递推是后续一切的源头
State value / Q value	差别在条件:只固定 s s s vs 同时固定 ( s , a ) (s,a) (s,a); v = ∑ a π q v=\sum_a\pi q v=∑aπq(全期望公式)
Bellman 方程	v = r + γ P v v=r+\gamma Pv v=r+γPv,policy evaluation 本质是解线性方程组
Bellman 最优方程	加权平均 → 对动作取 max;contraction mapping 保证 v ∗ v^* v∗ 存在唯一,*但 π ∗ \pi^ π∗ 可能不唯一**
DP	VI/PI/Truncated PI 是"评估多少"的连续谱
MC	采样平均估期望;必须等完整 episode;需要充分探索
TD	bootstrapping,每步可更新;TD target/error;方差小但有 bias
Sarsa / Q-learning	target 里用采样动作 vs 用 max → on-policy vs off-policy
函数逼近	参数共享带来泛化,也带来优化不稳定性
DQN	target network 解决"追逐移动目标";experience replay 打散相关性
Actor-Critic	actor 决策 + critic 打分;A2C 用 advantage 降方差
Robbins-Monro	"带噪声观测逼近确定性求根";TD 是它的一个实例
七组分类	model-based/free、on/off-policy、online/offline、behavior/target、探索/利用、episodic/continuing
统一视角	先问"要估计哪个期望",再问"需要什么样本"

这一节把 RL 的基础概念和算法主线铺完了。下一篇将正式进入 RL 在 LLM 中的应用------从 RLHF、PPO 到 GRPO,看这些方法如何复用上面这套"期望 + 样本 + bootstrapping"的框架。

MiniMind 学习笔记(十八):速通强化学习——从 MDP 到 PPO 的概念与算法地图