Lecture 6 · 强化学习与控制 · Reinforcement Learning & Control

对应 Maps to：Stanford CS229 Autumn 2018（Andrew Ng）Lecture 16 后半–20（MDPs & Value/Policy Iteration; Continuous State MDP & Model Simulation; Reward Model & Linear Dynamical System; RL Debugging and Diagnostics），以及 CS229 main notes（Andrew Ng & Tengyu Ma）Chapters 15–17（Reinforcement learning; LQR, DDP and LQG; Policy gradient）。 CS229 当前学期的课表需要 Stanford 登录才能看，所以本讲以公开的讲义和 2018 年的录像为准。这是 CS229 的最后一讲；更深入的 RL（TD、Q-learning、DQN、PPO、offline RL、探索理论）见同目录的 CS234。 配套代码 Code：code/lecture06/（numpy；5 个脚本，最长的约 20 秒） 预计阅读时间：2.5–3 小时（含运行代码）。这是一份复习讲义：假设你见过 MDP 和 value iteration，重点放在”为什么”、“什么时候会失效”和”它和前五讲的联系”上。

0. 本讲导航 · How to read this lecture

0.1 Learning goals

After this lecture you should be able to:

1. 用 MDP 的语言描述一个序贯决策问题，写出 $V^\pi$ 和 $V^\star$ 的 Bellman 方程，并说清它们一个是线性方程、一个是带 max 的不动点方程。
2. Explain why value iteration converges (γ-contraction), why it is often much faster than the $\gamma^k$ bound, and why policy iteration needs only a handful of iterations (it is Newton’s method).
3. Name the two traps of learning a model from experience: planning on an estimated model is overconfident (the optimizer’s curse), and acting greedily on it may never discover what it hasn’t tried.
4. For continuous states, compare discretization (curse of dimensionality) and fitted value iteration (regression inside VI — and why it may not converge).
5. 推出 LQR 的关键一步（二次函数经过线性动力学再取 min 仍是二次函数），解释 Riccati 增益为什么收敛到常数、certainty equivalence、LQG 的分离原理，以及 DDP / iLQR 在解决什么问题。
6. Derive REINFORCE from the likelihood-ratio trick, recognize the score function as the GLM gradient of Lecture 1, and explain what reward-to-go and baselines do to the variance.
7. Diagnose an RL system that “doesn’t work” with Ng’s three questions: is it the simulator, the RL algorithm, or the reward?

0.2 默认你已经会的 / 本讲会省略的

0.3 本讲地图 Map

§1  RL 问题：从监督学习到序贯决策；MDP；Bellman 方程
§2  有限 MDP：价值迭代（收缩）/ 策略迭代（Newton）/ 奖励定义最优 / 学模型 / 探索     ← 代码 01、02
§3  连续状态：模拟器 / 离散化与维数灾难 / fitted value iteration 及其不稳定性         ← 代码 03
§4  LQR：Riccati 递推 / vs 手调 / certainty equivalence / 线性化与 DDP / Kalman 与 LQG ← 代码 04 演示 1–4
§5  Policy gradient：REINFORCE / 得分函数 = GLM 梯度 / reward-to-go 与 baseline      ← 代码 05
§6  RL debugging：模拟器、算法还是奖励？                                              ← 代码 04 演示 5
§7  CS229 讲了什么、没讲什么（与 CS234 的对照）
§8–12 小结、常见误区、练习、延伸阅读、课程总结

0.4 Notation（和 CS229 main notes 一致）

符号上的一个约定：§1–3、§5 说”奖励”、最大化；§4（LQR）说”代价”、最小化，代价 = −奖励。CS229 讲义的 LQR 写成奖励 $-(s^\top U s + a^\top W a)$、价值 $s^\top\Phi_t s + \Psi_t$（$\Phi_t \preceq 0$），本讲的 $P_t = -\Phi_t$。两种写法的结果完全相同。

0.5 关于数字

讲义里所有实验数字都来自配套代码的实际输出（固定随机种子，python3 -W error 下运行两次逐字相同）。环境都是合成的小问题：Ng 的 4×3 网格、走廊、mountain car、双积分器、倒立摆。我们知道”真相”（能精确算出 $V^\star$、$\nabla\eta$、期望代价），所以能检查算法有没有学对；但数字本身不代表任何真实系统。

1. The RL problem · 从监督学习到强化学习

1.1 What changes when there are no labels

前五讲都有一个”正确答案”可以比较：标签 $y$（监督学习），或者数据本身（无监督学习）。Andrew Ng 讲 RL 时用的例子是自主直升机：在每个时刻该把操纵杆推多少？没有人能给出每一时刻的”正确”动作，但我们能说出飞得好不好（稳不稳、有没有坠毁）。RL 的设定就是：只给一个奖励信号，让算法自己找出动作。

这带来三个监督学习里没有的困难：

• Delayed reward / credit assignment：坠机是因为刚才那一下，还是 10 秒前的某个决定？
• Sequential decisions：现在的动作改变了将来的状态，所以不能把每一步当作独立样本。
• The data depend on your own actions：你只看得到你走过的地方的后果（§2.5 的探索问题）。第 3 讲的 i.i.d. 假设在这里不成立。

1.2 Markov decision processes

An MDP is a tuple $(\mathcal{S}, \mathcal{A}, \{P_{sa}\}, \gamma, R)$. Start in $s_0$, choose $a_0$, move to $s_1 \sim P_{s_0a_0}$, choose $a_1$, and so on. The return is

Why discount? Three levels of answer: (1) mathematically it keeps the infinite sum finite (at most $R_{\max}/(1-\gamma)$) and makes the Bellman operator a contraction (§2.1); (2) economically, a dollar today is worth more than a dollar tomorrow; (3) as a model, $1-\gamma$ can be read as a per-step probability that the world ends. $1/(1-\gamma)$ is roughly how many steps ahead the agent “looks”.

策略 $\pi: \mathcal{S} \to \mathcal{A}$ 的价值 $V^\pi(s)$ 是从 $s$ 出发、按 $\pi$ 行动的期望回报。最优价值 $V^\star(s) = \max_\pi V^\pi(s)$。一个重要的事实（这里不证明）：存在一个策略 $\pi^\star$ 同时在所有状态上达到最优，而且可以取成确定性的。

1.3 Bellman equations

把回报拆成”这一步的奖励 + 折扣后的将来”：

Two equations, two very different objects:

• 第一个是线性方程组：$|\mathcal{S}|$ 个未知数、$|\mathcal{S}|$ 个方程，$V^\pi = (I - \gamma P_\pi)^{-1}R$。这就是 policy evaluation。
• 第二个因为有 $\max$，是非线性的不动点方程 $V^\star = TV^\star$。没有封闭解，要迭代 —— 这就是 §2 的两个算法。

本讲的实现约定：终止状态（如网格世界的 ±1 出口）进入时拿到 $R(s)$，之后什么也没有；代码里把它的转移概率行设成全 0，Bellman 方程在那里自动变成 $V(s) = R(s)$。

2. Finite MDPs · 有限 MDP：规划、学模型与探索

2.1 Value iteration and the contraction argument

Value iteration just applies $T$ repeatedly: $V_{k+1} = TV_k$. Why does this converge, from any starting point? The key step is one inequality. For any two value functions $V, U$ and any state $s$,

（第一步用了 $|\max_a f(a) - \max_a g(a)| \le \max_a|f(a) - g(a)|$，第二步用了”概率加权平均不超过最大值”。）所以 $T$ 是 $\infty$-范数下的 $\gamma$-收缩（contraction），由 Banach 不动点定理，$V^\star$ 唯一，而且

这是最坏情况的保证。代码 01_value_policy_iteration.py 演示 1 在 Ng 课上的 4×3 网格世界（转移 0.8 / 0.1 / 0.1，每步 $R = -0.02$，$\gamma = 0.99$）上比较实际误差和上界：

$\gamma = 0.99$ 时上界要约 2300 步才降到 $10^{-10}$，可 $R = -0.02$ 时 VI 只用了 41 步。原因是回合会结束：最优策略下 agent 很快走到出口，后期误差每步乘以 $\gamma P_{\pi^\star}$ 的谱半径 0.433，而不是 $\gamma$。“每一步有一定概率终止”等价于一个更小的有效折扣。$R = +0.02$ 时活着本身有奖励，最优策略是永远不进出口：回合不结束，前几步的误差恰好等于上界，后期速率 0.990 ≈ $\gamma$，要 1842 步。

两个实践要点：

• The greedy policy converges long before the values. 从第 11 步起，对 $V_k$ 贪心的策略已经是最优的，而 $V_{11}$ 的误差还有 0.08。我们要的是策略，价值只是中间产物。
• The stopping rule is not the error. $\lVert V_{k+1} - V_k\rVert < \varepsilon$ 只保证 $\lVert V_{k+1} - V^\star\rVert \le \gamma\varepsilon/(1-\gamma)$。$\gamma$ 接近 1 时这个放大很可观（下一节表格的第 4 列）。

2.2 Policy iteration is Newton’s method

Policy iteration alternates exact evaluation $V^{\pi_k} = (I - \gamma P_{\pi_k})^{-1}R$ with greedy improvement. The policy improvement theorem guarantees $V^{\pi_{k+1}} \ge V^{\pi_k}$ everywhere, and there are finitely many deterministic policies, so it terminates. But “finite” is $|\mathcal{A}|^{|\mathcal{S}|}$ — why does it take only a handful of steps in practice?

The answer is that policy iteration is Newton’s method on the Bellman equation (Puterman & Brumelle, 1979). Let $F(V) = TV - V$; we want $F(V) = 0$. $T$ is piecewise linear: near $V$, $TV = R + \gamma P_{\pi_V}V$ where $\pi_V$ is greedy with respect to $V$, so the Jacobian of $F$ is $\gamma P_{\pi_V} - I$. One Newton step gives

— exactly “act greedily, then evaluate exactly”. Value iteration is the fixed-point iteration $V \leftarrow TV$, the analogue of fixed-step GD in Lecture 1: linear convergence at the contraction rate. 代码 01 演示 2 在一个随机 MDP（200 个状态、4 个动作、没有终止状态）上把 $\gamma$ 推向 1：

VI 的步数 $\propto 1/(1-\gamma)$，PI 几乎不变；PI 的误差越到后面缩得越快（Newton 的超线性收敛，对照第 1 讲 §3.7）。在 4×3 网格上，PI 从”全部向下”出发，改进 4 轮就找到最优策略（第 5 轮评估只是确认不再需要改），在 $4^9 = 262144$ 个确定性策略里只看了 5 个。

代价也和 Newton 一样：每轮要解 $|\mathcal{S}|\times|\mathcal{S}|$ 的线性方程组（$O(|\mathcal{S}|^3)$），VI 每步只要 $O(|\mathcal{S}|^2|\mathcal{A}|)$。状态很多时用折中的 modified policy iteration：评估时只做几次迭代。

2.3 The reward defines what “optimal” means

Same grid, same dynamics, only the per-step reward $R(s)$ changes (code 01, demo 3, $\gamma = 0.99$):

一个看起来无害的小数字能完全改变行为。奖励函数不是”告诉 agent 怎么做”，而是”定义什么叫好”—— §6 的调试流程里第三个问题就是”奖励函数是不是错了”。（CS234 第 2 讲的 05_gridworld.py 在同一个网格上把 $\gamma$ 和噪声也扫了一遍。）

2.4 Learning a model from experience

So far $P_{sa}$ and $R$ were given. CS229’s answer when they aren’t is the simplest possible one: count.

这就是第 1 讲的 MLE：每个 $(s, a)$ 的下一状态服从一个 categorical 分布，它的 MLE 是频率。然后在 $\hat P$ 上做 VI，执行得到的策略，收集更多数据，再估计 …… 这是最朴素的 model-based RL。 代码 02_model_based_rl.py 演示 1 在 4×3 网格里随机乱走，学模型、规划，再在真实环境里评估（每行 50 次重复的平均，$V^\star(\text{start}) = 0.780$）：

两件值得记住的事：

• 不需要把模型学得很准：100 个回合时 TV 误差还有 0.045，84% 的情况已经得到最优策略。和 §2.1 一样，只要动作的排序对了就行。
• 在学到的模型上规划会过度自信（optimizer’s curse）：$\hat V - V^{\hat\pi}$ = +0.260（3 个回合）、+0.127（10 个）、+0.009（100 个）。在有噪声的估计上取 max，会系统性地挑中那些”恰好被高估”的动作（练习 3）。这是所有”先学模型再优化”方法的通病，§3.4 的 fitted VI 里还会以 maximization bias 的形式再出现一次。

2.5 The exploration problem (briefly)

CS229 的循环是”执行当前最优策略 → 更新模型 → 重新规划”。它有一个致命的盲点：数据是 agent 自己的行为产生的。演示 2 是一条走廊：从状态 2 出发，左边 2 步是 +1 的出口，右边 7 步是 +10 的出口（$\gamma = 0.95$，最优是向右，$V^\star = 6.983$；向左只有 $0.902$）。每个 agent 先随机走一个回合，再按计划走 30 个回合，独立跑 200 次（第 $i$ 次运行时三个 agent 的随机回合相同）：

• greedy 只有在第一个随机回合碰巧走到右边时才学会向右（随机游走先到 9 的概率是 2/9 ≈ 0.22，200 次的标准误约 0.03）。否则模型只见过 +1，计划就是”向左”，执行”向左”又只会看到 +1 —— 永远不会知道右边有什么。模型没有估计错；它只是从来没有关于右边的数据。
• ε-greedy 一次也没帮上：200 次运行里靠随机动作多找到 +10 的次数是 0。要连续很多步”恰好”随机地向右，概率随距离指数下降。这种”抖动式”探索（dithering）在需要深度探索的问题上几乎无效。
• 乐观（optimism in the face of uncertainty）：把没试过的 $(s, a)$ 当成”通往一个每步都拿 $R_{\max}$ 的天堂”。agent 会有计划地去试每个没试过的动作，试过之后乐观自动消失。代价是前期多走一倍的路。

CS229 只点到为止。Regret、UCB、Thompson sampling、R-max、PSRL 这些系统的探索理论见 CS234 第 11–13 讲。

3. Continuous states · 连续状态

3.1 Simulators

直升机的状态是连续的（位置、姿态、速度、角速度，12 维），表格 $V(s)$ 存不下。CS229 的思路是先有一个模拟器（simulator / model）：给定 $(s_t, a_t)$，返回 $s_{t+1}$ 或它的一个样本。模拟器从哪来？

• Physics：刚体动力学、空气动力学的方程。准确，但写起来费力，而且总有没建模的效应。
• Learned from data：让人类飞一会儿，记录 $(s_t, a_t, s_{t+1})$，然后拟合 $s_{t+1} = As_t + Ba_t$（就是第 1 讲的线性回归，每个输出维度一个）。Ng 的直升机就是这样做的，再在线性模型上加噪声 $\epsilon_t \sim \mathcal{N}(0, \Sigma)$ 让它变成随机的。Ng 课上的建议：训练时用随机模拟器，否则策略会利用模拟器”过于完美”的地方，到了真实世界就脆弱。

有了模拟器，有两条路：离散化，或者用函数逼近 $V$。

3.2 Discretization and the curse of dimensionality

把状态空间切成格子，每个格子当作一个离散状态，转移概率从模拟器采样估计（§2.4 的计数法，只是数据来自模拟器），然后做 VI。代码 03_continuous_fitted_vi.py 演示 1 用 mountain car：一辆动力不足的小车要开上右边的山顶，必须先往左倒车蓄势 —— “先远离目标才能到达目标”，需要向前看很多步。状态 = (位置, 速度)，每步奖励 −1，$\gamma = 0.99$；评估 100 个固定起点的平均到达步数（上限 1000）：

$N = 5$ 太粗，表示不出”先倒车”这种精细的策略；$N \ge 80$ 基本饱和。两个代价：

1. Resolution：$V$ 和 $\pi$ 在一个格子内是常数（piecewise constant），真实的 $V$ 却在格子内部变化。
2. Curse of dimensionality：每维 $N$ 段，$d$ 维要 $N^d$ 个格子。每维 20 段时，2 维 400 个，4 维（cart-pole）16 万，6 维 6400 万，12 维的直升机 $4\times10^{15}$。CS229 讲义的经验法则：1–2 维离散化很好用，3–4 维要小心地设计格子，6 维以上基本不行。

3.3 Fitted value iteration

The fix is the same as everywhere else in ML: replace the table by a parametric function $V(s) \approx \theta^\top\phi(s)$, with a number of parameters that doesn’t grow like $N^d$. Fitted value iteration (CS229 main notes, Ch. 15):

1. Sample states $s^{(1)}, \dots, s^{(m)}$ once.
2. Repeat:
   • For each $i$ and each action $a$, sample $k$ next states $s'_1, \dots, s'_k \sim P_{s^{(i)}a}$ from the simulator and set $q(a) = R(s^{(i)}) + \gamma\frac{1}{k}\sum_j V(s'_j)$.
   • $y^{(i)} = \max_a q(a)$ — one Bellman backup on the samples.
   • $\theta := \arg\min_\theta \sum_i\big(\theta^\top\phi(s^{(i)}) - y^{(i)}\big)^2$ — least squares from Lecture 1.
3. Act greedily, using the simulator to look one step ahead.

So FVI is VI where each sweep is a supervised regression problem: the Bellman backup produces the labels, least squares fits them. Demo 2 ($m = 2000$, 1000 sweeps, no regularization; mountain car is deterministic so $k = 1$; the true $V$ lies in $[-100, -1]$):

(For comparison: discretization with $N = 80$, 6400 cells → 98.8 steps.)

• Low-degree polynomials are too rigid to represent the shape of $V$. RBFs are local features, and 82 of them come close to what 6400 cells achieve. But 15×15 is no better than 9×9: more features did not buy a better policy.
• Every row has positive values of $V$, although the truth is $\le -1$. Function approximation has errors, but the greedy policy only asks which action has the larger $V(s')$, so the policy can be fine while $V$ is wrong — and FVI’s $V$ should not be read as “steps to go”.
• For RBF 9×9 and 15×15, θ is still changing after 1000 sweeps. Exact VI always converges; FVI may not settle.

3.4 Fitted VI need not converge

演示 3 跟踪 RBF 15×15 的迭代过程（各记录点上的 $\lVert\Delta\theta\rVert_\infty$，以及贪心策略的失败率）：

不加正则化时，$\theta$ 的变化量忽大忽小，几百轮都没有稳定的下降趋势，系数大到 833（高度重叠的 RBF 用大的正负系数互相抵消），前 300 轮的贪心策略全部失败；最后慢慢停下来。多采样没有治好它：$m = 10000$ 同样乱跳了几百轮，最后停在一个更差的地方（8% 失败）。加一点 ridge，$\lVert\Delta\theta\rVert$ 就像收缩映射一样单调下降，第 100 轮的策略已经全部成功。

Why? Exact VI is a contraction in $\lVert\cdot\rVert_\infty$. Least-squares fitting is a projection that is optimal in (sample-weighted) $\lVert\cdot\rVert_2$ — it can make the error larger at some states (extrapolation, wild cancelling coefficients). The composition “fit ∘ backup” need not be a contraction in any norm, so errors can be amplified from one sweep to the next, oscillate, or settle somewhere that depends on details (Tsitsiklis & Van Roy, 1996). Gordon (1995) showed that if the regressor is an averager — prediction = a weighted average of training targets, as in $k$-NN or discretization — FVI does converge. Ridge doesn’t make least squares an averager, but it tames the large coefficients.

Ridge 修好的是”不稳定”，不是”高估”。三种设置下 $V$ 的最大值都在山顶旁边（$p \approx 0.45$–0.5），而且那里的回归目标本身就是正的（3.14、12.13、4.33）。机制：山顶是一个悬崖（再走一步就到的状态 $V = -1$，山顶本身为 0 且不在回归样本里），光滑的特征在悬崖边冲过头；bootstrapping 把高估喂进邻居的目标 $y = -1 + \gamma V(s')$，$\max$ 又专挑被高估的那个动作 —— 高估一轮轮传开。这就是 maximization bias，和 §2.4 的 optimizer’s curse 是同一件事。它的后代 DQN 有同样的问题（Double DQN 就是为它设计的），“函数逼近 + bootstrapping + off-policy”会发散的现象叫 deadly triad（CS234 第 4–5 讲）。

4. Linear quadratic regulation · LQR、DDP 与 LQG

4.1 The one continuous case with an exact solution

Linear dynamics, quadratic cost, finite horizon. Why care about such a special case?

• 任何光滑的非线性系统在平衡点附近都近似线性，任何光滑的代价在最小值附近都近似二次。“让直升机悬停在原地”、“让倒立摆保持竖直”都是这个形状（§4.4）。
• 它有精确解：$V$ 恰好是二次函数，最优策略恰好是线性反馈 $a_t = -K_ts_t$。连续状态、无穷多个状态，却只需要一个 $n\times n$ 矩阵 —— 不需要离散化，也不需要 FVI。

4.2 The Riccati recursion

动态规划从 $t = T$ 往回做。关键一步：假设 $V_{t+1}(s) = s^\top P_{t+1}s + c_{t+1}$，那么

括号里对 $a$ 是凸二次函数（$W \succ 0$），令导数为 0 得 $a^\star = -K_ts$，代回去仍是 $s$ 的二次函数 —— “二次函数经过线性动力学、再对动作取 min，还是二次函数”，所以归纳成立：

$P_t$ 的递推叫 (discrete-time) Riccati equation。它就是线性-二次情形下的价值迭代：每一步 backup 都能用一个矩阵精确表示。

代码 04_lqr_lqg.py 演示 1 用双积分器（直线上的小车，$s$ = [位置, 速度]，$a$ = 力，$dt = 0.1$，$U = \text{diag}(1, 0.1)$，$W = 0.1$，$T = 100$）：

• 离终点很远时 $K_t$ 是常数 $K_\infty$，只有最后十来步迅速变小：快结束时，“现在用力、以后享受小偏差”的买卖不划算了。
• 时域每多 10 步，$\lVert K_0 - K_\infty\rVert$ 大约缩小 10 倍：Riccati 递推本身是一个收缩的不动点迭代（又是 §2.1）。所以无限时域 LQR = 迭代 Riccati 到不动点（discrete algebraic Riccati equation, DARE），实践中常常直接用 $K_\infty$。
• 从 $s_0 = [1, 0]$ 出发，预测代价 $s_0^\top P_0s_0 = 9.077561$，实际执行的代价也是 9.077561，逐位相同：$V_t$ 是精确的，不是近似。

4.3 LQR vs hand tuning; certainty equivalence

A PD controller $a = -(k_p\cdot\text{position} + k_d\cdot\text{velocity})$ is exactly a linear feedback $a = -[k_p, k_d]\,s$. Demo 2 computes expected costs exactly by propagating covariances ($s_0 \sim \mathcal{N}(0, \text{diag}(1, 0.25))$, no sampling error):

A brute-force search over $k_p, k_d \in \{0.5, 0.75, \dots, 6\}$ finds the best PD gains to be (2.75, 2.50) both with and without noise — that is $K_\infty$. Two lessons:

• LQR does the tuning for you — given $U$ and $W$. The hand-tuning problem doesn’t disappear; it moves into choosing the cost matrices. That is reward design again (§2.3, §6).
• Certainty equivalence：过程噪声让每一行的代价都变大，但不改变最优增益。Riccati 递推里 $K_t$ 根本不含 $\Sigma_w$；噪声只贡献一个和策略无关的常数 $c_0 = \sum_t\operatorname{tr}(\Sigma_wP_{t+1}) = 2.570$（预测 $\operatorname{tr}(P_0\Sigma_0) + c_0 = 9.769 + 2.570 = 12.339$，和精确计算一致）。直觉：加性高斯噪声是”不管你怎么做都会被吹偏这么多”，它对任何策略都一样。（这个结论依赖线性 + 二次 + 加性高斯；有约束或非线性时不成立。）

4.4 Nonlinear dynamics: linearization, DDP and iLQR

For a nonlinear simulator $s_{t+1} = f(s_t, a_t)$, the simplest move is to linearize around a point you want to stay near (e.g. hover, or the upright pendulum): $f(s, a) \approx f(\bar s, \bar a) + \nabla_sf\,(s - \bar s) + \nabla_af\,(a - \bar a)$, then run LQR. Demo 3 uses an inverted pendulum ($\ddot\theta = g\sin\theta + u$, $\theta = 0$ upright, $mgl = 9.81$), linearized at the top, started at rest from angle $\theta_0$ (1 = stabilized after 6 s):

结果和”离线性化点远了就失效”的简单说法不完全一样：力矩不限时，线性化的 LQR 从 3.0 rad（离竖直向下只差 8°）都能救回来，代价是约 7 倍 $mgl$ 的峰值力矩 —— 力气够大时，“偏了就往回推”这条线性规则在很大范围内都对。力矩上限低于 $mgl$ 时，成功的边界（0.5、0.3）几乎正好是”静止撑住”的极限 $\arcsin(u_{\max}/mgl) = 0.53$、$0.31$。再远，任何控制器都没法直接推上去，必须先往反方向摆、一来一回地荡上去（swing-up）。这是一个非线性的计划，线性模型根本表示不出来：在线性模型里，$\theta$ 再大也只是”多推一点”。

这就是 DDP（differential dynamic programming）/ iLQR 的动机：不在一个固定点线性化，而是沿着当前猜测的轨迹 $(\bar s_t, \bar a_t)$ 线性化（DDP 还保留动力学的二阶项），解一个时变 LQR 得到改进的轨迹，再沿新轨迹线性化 …… 迭代到收敛。每一轮都是 §4.2 的 Riccati 递推，所以它继承了 LQR 的效率；加上动作约束（control-limited DDP），它能找到 swing-up 这样的轨迹。它是机器人轨迹优化和 MPC 的主力。

4.5 Partial observability: Kalman filter and LQG

Real sensors are noisy and incomplete: we observe $y_t = Cs_t + v_t$, $v_t \sim \mathcal{N}(0, \Sigma_v)$, not $s_t$. In the linear-Gaussian world the belief about $s_t$ stays Gaussian, so it’s enough to track a mean and a covariance — the Kalman filter:

（这里的 $K$ 是 Kalman gain，不是 LQR 的增益。）修正量 = gain × “观测比预测多出来的部分”（innovation）：观测噪声大 → 更相信预测；当前不确定性大 → 更相信观测。数学上它就是”联合高斯分布的条件分布”（第 5 讲 factor analysis 的 E 步用的也是它）在时间上的递推。

LQG = Kalman filter + LQR: plug the estimate into the controller, $a_t = -K_ts_{t|t}$. In the linear-quadratic-Gaussian setting this is not merely a reasonable heuristic but optimal (the separation principle: estimation and control can be designed separately — the other face of certainty equivalence). Demo 4 observes only the position ($y = p + \mathcal{N}(0, \sigma^2)$); 2000 simulations per setting, with the same random numbers for all three controllers:

（oracle 的精确期望代价是 12.339；表中平均值的标准误约 0.3。）差分 $(y_t - y_{t-1})/dt$ 把观测噪声放大了约 $\sqrt2/dt \approx 14$ 倍，LQR 拿着这么吵的速度去用力，代价是 oracle 的上百倍。Kalman 滤波利用动力学模型把历史观测融合起来：$\sigma = 0.3$ 时位置误差 0.148，小于观测本身的噪声，LQG 的代价是 oracle 的 2.1 倍、naive 的 1/52。看不到真实状态总要付出代价，但模型能把这个代价压得很低。

5. Policy gradient · 策略梯度

5.1 Why search over policies directly?

Sections 2–4 all compute $V$ (or a model) first and derive the policy from it. The alternative is to parameterize the policy $\pi_\theta$ and run gradient ascent on the expected return $\eta(\theta)$. Why would we?

• Continuous / high-dimensional actions: $\max_a Q(s, a)$ over a continuous action is itself an optimization problem.
• Simple policies can be good even when $V$ is complicated: mountain car’s $V$ has cliffs and spiral boundaries, yet “push in the direction you are moving” is a very simple policy.
• Stochastic policies are sometimes optimal (partial observability), and they make $\eta(\theta)$ differentiable even when the dynamics aren’t.
• No model needed (next subsection). Ng’s helicopter used policy search on a learned simulator (PEGASUS: fix the simulator’s random seeds so that $\eta(\theta)$ becomes a deterministic function you can optimize).

5.2 REINFORCE and the likelihood-ratio trick

$\eta(\theta) = \mathbb{E}_{\tau\sim p_\theta}[f(\tau)]$，$\tau = (s_0, a_0, s_1, a_1, \dots)$，$f(\tau)$ 是总回报。直接对期望求导的困难是：$\theta$ 在分布里，不在被积函数里。Likelihood-ratio（score function）技巧：

而 $\log p_\theta(\tau) = \log p(s_0) + \sum_t\big[\log\pi_\theta(a_t \mid s_t) + \log P_{s_ta_t}(s_{t+1})\big]$，动力学那一项和 $\theta$ 无关，求导时消失：

所以只要能采样轨迹，就能无偏地估计梯度，不需要知道 $P$，也不需要 $f$ 可导。这就是 REINFORCE（Williams, 1992）。

The score function is a GLM gradient. 代码 05_policy_gradient.py 演示 1：

• Softmax policy $\pi_\theta(a \mid s) \propto \exp(\theta_a^\top\phi(s))$：$\nabla_\theta\log\pi_\theta(a \mid s) = \phi(s)\,(e_a - \pi_\theta(\cdot \mid s))^\top$ —— 和第 1 讲 §4.6 softmax 回归单个样本的梯度 $x\,(y - p)^\top$ 一模一样，只是”标签”换成了自己刚做的动作。
• Gaussian policy $a \sim \mathcal{N}(\theta^\top x, \sigma^2)$：$\nabla_\theta\log\pi = (a - \theta^\top x)\,x/\sigma^2$ —— 线性回归的”误差 × 输入”。

So REINFORCE is return-weighted maximum likelihood on your own actions: fit a GLM to the actions you took, weighting each by how well things went afterwards. 代码里 reinforce_grad 就是这么写的：$\hat g = X^\top\text{diag}(w)(Y - P)/M$，$X$ = one-hot 状态，$Y$ = one-hot 动作，$w$ = 回报。第 1 讲的主线”loss = −log-likelihood”在 RL 里变成了”objective = 回报加权的 log-likelihood”。

还有一个性质撑起了下一节：得分函数的期望为 0，$\mathbb{E}_{a\sim\pi}[\nabla\log\pi(a)] = \nabla\sum_a\pi(a) = \nabla 1 = 0$。演示 1 中 softmax 的情形精确为 0，高斯的情形 20 万个样本的平均是 −0.0023（标准误 0.0026）。

5.3 Variance: reward-to-go and baselines

REINFORCE 无偏，但方差很大。两个几乎免费的改进（CS229 main notes Ch. 17）：

1. Reward-to-go：动作 $a_t$ 影响不了它之前（和当时）的奖励，把 $f(\tau)$ 换成 $G_t = \sum_{j>t}R(s_j)$。去掉的部分期望为 0，只贡献噪声。
2. Baseline：再减去任何不依赖 $a_t$ 的 $b(s_t)$：$\mathbb{E}[\nabla\log\pi(a_t \mid s_t)\,b(s_t)] = b(s_t)\cdot\mathbb{E}[\nabla\log\pi] = 0$，期望不变。好的 baseline 让权重变成”比平均好多少”（advantage）。

演示 2 用一条 5 个状态的走廊（状态 4 每步 +1，10% 滑动，固定时域 $H = 10$，表格 softmax，$\theta = 0$），精确算出 $\nabla\eta$ 后比较四种估计量（每种 20000 条轨迹）。再给每一步奖励加一个常数 $c$：时域固定时所有轨迹的回报都多 $cH$，最优策略和 $\nabla\eta$ 都不变：

All four estimators are unbiased (the deviation is of the same size as the expected sampling error). With $c = 1$ the variance of the full-return estimator grows 64×, and a 10-trajectory estimate is nearly uncorrelated with the true gradient: every $\nabla\log\pi$ is multiplied by a large positive number ≈ $cH$, so “every action taken gets reinforced”, and the useful signal (which action was better than which) drowns. The two baseline rows are identical to their $c = 0$ counterparts: the baseline subtracts the constant exactly. Using a learned $V(s)$ as the baseline is actor-critic (CS234 Lecture 7).

5.4 What the variance does to learning

Demo 3: 10 trajectories per update, learning rate 0.1, 20 independent runs, evaluated with the exact $\eta(\theta)$ (the table shows $\eta - cH$; $\eta^\star = 4.730$):

(LOO = leave-one-out: trajectory $i$‘s baseline is the average $G_t$ of the other trajectories in the batch, which does not depend on its own actions, so it is unbiased. In RL fine-tuning of LLMs this is called RLOO; GRPO’s “group mean” is the same idea.)

• $c = 0$ 时 baseline 几乎没有影响：三条曲线几乎重合，都跟着精确梯度走。方差只差约 2 倍，被 200 步平均掉了。这和预想的”baseline 一定明显加速”不一样 —— baseline 不是在任何问题上都有显著效果。
• $c = 1$ 时差别就出来了。全回报平均只到 3.704，最差的一次 0.082：训练结束时它在起点向右的概率只剩 0.008（一直往墙上撞），$\lVert\nabla\eta\rVert$ 从 0.663 缩到 0.052，几乎出不来了 —— 高方差的更新把 softmax 推进了一个很差的、几乎确定性的策略（premature convergence）。加 baseline 后的曲线和 $c = 0$ 时一样。奖励的”零点”在 RL 里本来是任意的（每步 +1 存活奖励、每步 −1 时间惩罚都很常见），好的估计量不应该被它左右。
• 精确梯度 200 轮后也只到 4.589：softmax 越接近确定性，梯度越小（$\pi(1-\pi)$ 因子），普通梯度上升在最后一段很慢。Natural policy gradient / TRPO / PPO 改的就是这个几何问题（CS234 第 7 讲）。

6. RL debugging and diagnostics · 是模拟器、算法还是奖励？

Ng 在 2018 年最后一讲用直升机讲了一个调试流程。系统由三个部件组成，各带一个假设：

1. Simulator：模拟器足够准确，在模拟器里飞得好的策略在现实里也飞得好。
2. RL algorithm：算法能在模拟器里找到（近似）最大化奖励的策略。
3. Reward function：最大化这个奖励 ⇔ 飞得好。

RL 策略 $\pi_{\text{RL}}$ 在现实里飞得不好时，按顺序问三个能用数字回答的问题（$\pi_{\text{human}}$ 是飞得好的人类驾驶员）：

1. $\pi_{\text{RL}}$ 在模拟器里飞得好、在现实里飞得不好？→ 模拟器的问题。
2. 否则，比较奖励：$V^{\pi_{\text{RL}}}(s_0) < V^{\pi_{\text{human}}}(s_0)$？存在一个奖励更高的策略，RL 却没找到 → RL 算法的问题。
3. 否则 $V^{\pi_{\text{RL}}}(s_0) \ge V^{\pi_{\text{human}}}(s_0)$：RL 把奖励优化得比人还好，却飞得更差 → 奖励函数的问题。

代码 04 演示 5 在双积分器上分别注入三种错误（“飞行质量” $q$ = 位置误差的 RMS，是我们真正关心的东西；人类 = PD (3, 2)，$q = 0.261$；$q \le 1.25\times0.261$ 算飞得好；$J$ = 按 RL 用的代价函数在真实系统上的期望代价）：

• 模拟器以为飞行器轻 10 倍，LQR 选了偏软的增益：模拟器里比人还好（0.174），现实里软绵绵的（0.367）。该做的是收集真实数据重新拟合动力学（§3.1 的回归），而不是去调算法或奖励。
• 短视的规划器在模拟器和现实里一样差（模拟器没问题）；人类的代价 13.00 远低于 RL 的 49.59 —— 有更好的策略它没找到。
• 忘了位置的代价函数：RL 的代价 4.56 比人类的 16.71 还低，它完美地完成了”最小化这个代价”，却只学会了刹车、停在哪儿算哪儿。

The value of the procedure is that it turns a vague complaint (“it doesn’t fly well”) into comparisons you can compute, so you don’t spend months improving the wrong component. It is the same idea as the ML diagnostics of Lecture 3 (“is it the optimization algorithm or the objective?”): check whether a solution you know to be better is actually better under your objective.

7. What CS229 covers, and where to go next · 与 CS234 的关系

CS229’s treatment of RL is model-centric: with a known model, plan (VI / PI / LQR); without one, learn the model first (counting, regression) or use a simulator. It says almost nothing about the large family of methods that learn values directly from experience without a model. CS234, in the same folder, fills that in:

8. 小结 · Summary

Six takeaways:

1. Bellman equations are fixed-point equations: VI is fixed-point iteration (a $\gamma$-contraction, often much faster when episodes end), PI is Newton’s method, and the Riccati recursion is VI when $V$ is exactly quadratic.
2. Optimizing over an estimate is biased upward. Planning on a learned model, or taking $\max$ over a fitted $V$, systematically overestimates (optimizer’s curse, maximization bias).
3. Your data depend on your actions. Greedy and ε-greedy can miss what they never try; optimism explores on purpose.
4. Function approximation inside dynamic programming is not just regression. Errors feed back through bootstrapping; FVI may oscillate or settle in the wrong place, and regularization (Lecture 3) helps.
5. REINFORCE is weighted maximum likelihood on your own actions, with a GLM score function from Lecture 1. Baselines don’t change the expectation but can change the variance by orders of magnitude.
6. The reward/cost is part of the design. It defines “optimal” (grid world), replaces hand-tuning (LQR), and is one of the three things to check when a system fails (§6).

9. 常见误区 · Common pitfalls

• “VI needs $\gamma^k$ to be tiny before the policy is right.” The bound is worst case; with termination it can be orders of magnitude faster, and the greedy policy is usually optimal long before $V$ converges.
• “‖V_{k+1} − V_k‖ is small, so V is accurate.” The error can be $\gamma/(1-\gamma)$ times larger — 1000× at $\gamma = 0.999$.
• “The learned model says this plan is worth 0.53, so it is.” Planning on an estimated model overestimates (0.531 promised vs 0.271 actual with 3 episodes).
• “ε-greedy takes care of exploration.” Not when the reward is many deliberate steps away; it found the far exit 0 extra times in 200 runs.
• “Fitted VI is VI with a regressor, so it converges like VI.” It may not; watch $\Delta\theta$ and the range of $V$ (positive values when all rewards are negative are a red flag).
• “Noise should change the LQR gains.” Not for additive Gaussian noise in the LQ setting (certainty equivalence) — it only adds a constant cost. It does matter with constraints, nonlinearity, or multiplicative noise.
• “Adding a constant to every reward is harmless.” With termination it changes the optimal policy (§2.3); in policy gradient without a baseline it inflates the variance (64× for $c = 1$ in §5.3).
• “The RL policy fails, so let’s tune the reward.” Ask the three questions in order first (§6).

10. 练习 · Exercises

Exercise 1 (Contraction and iteration counts). (a) Prove $\lVert TV - TU\rVert_\infty \le \gamma\lVert V - U\rVert_\infty$. (b) Starting from $V_0 = 0$ with $|R| \le R_{\max}$, how many iterations guarantee $\lVert V_k - V^\star\rVert_\infty \le \varepsilon$? (c) In code 01 with $\gamma = 0.99$ and step reward $-0.02$, VI needed only 41 iterations. Use “each step has some probability of terminating” to explain why the actual rate is $\rho(\gamma P_{\pi^\star})$ rather than $\gamma$.

(a) For each $s$: $|\max_af(a) - \max_ag(a)| \le \max_a|f(a) - g(a)|$ with $f(a) - g(a) = \gamma\sum_{s'}P_{sa}(s')(V - U)(s')$, whose absolute value is at most $\gamma\lVert V - U\rVert_\infty$ (a probability-weighted average never exceeds the maximum). (b) $\lVert V_0 - V^\star\rVert_\infty \le R_{\max}/(1-\gamma)$, so we need $\gamma^kR_{\max}/(1-\gamma) \le \varepsilon$, i.e. $k \ge \log\frac{R_{\max}}{\varepsilon(1-\gamma)}\big/\log\frac1\gamma \approx \frac{1}{1-\gamma}\log\frac{R_{\max}}{\varepsilon(1-\gamma)}$. (c) Once the greedy policy has settled on $\pi^\star$, the error propagates as $e_{k+1} = \gamma P_{\pi^\star}e_k$ among non-terminal states. Terminal rows are zero, so $P_{\pi^\star}$ is sub-stochastic — probability mass leaks out every step — and its spectral radius is below 1, giving the effective rate $\rho(\gamma P_{\pi^\star}) = 0.433 < \gamma$. When the agent never wants to finish (+0.02 per step), $P_{\pi^\star}$ is stochastic on the non-terminal states, its spectral radius is 1, and the rate returns to $\gamma$.

练习 2（PI = Newton）. 设 $F(V) = TV - V$。证明：在 $V$ 处对 $F$ 做一步 Newton 法（用贪心策略 $\pi_V$ 给出的 Jacobian $\gamma P_{\pi_V} - I$），得到的正是 $V^{\pi_V}$。为什么 PI 的误差序列（9 → 3 → 0.6 → 0.06 → 0）越到后面缩得越快？

$V - (\gamma P_\pi - I)^{-1}(R + \gamma P_\pi V - V) = V + (I - \gamma P_\pi)^{-1}\big(R - (I - \gamma P_\pi)V\big) = (I - \gamma P_\pi)^{-1}R = V^\pi$。$T$ 是有限个仿射函数的上包络（每个确定性策略一个），所以 $F$ 是凸的分段线性函数。Newton 法在分段线性函数上：一旦当前点落在”正确的那一段”（贪心策略 = $\pi^\star$），下一步就精确落到根上。这就是为什么 PI 在有限步内精确终止，而不只是渐近收敛；越到后面，贪心策略和 $\pi^\star$ 的差别越小，误差缩得越快。

Exercise 3 (The optimizer’s curse). There are $K$ actions, all with true value 0, and estimates $\hat Q_a = \epsilon_a$, $\epsilon_a \overset{\text{iid}}{\sim}\mathcal{N}(0, \sigma^2)$. (a) For $K = 2$, compute $\mathbb{E}[\max_a\hat Q_a]$. (b) If we pick $\hat a = \arg\max_a\hat Q_a$, what is its true value, and what is the expected “believed minus true” value? (c) Relate this to the table of code 02: why does the gap shrink with more data?

(a) $\max(\epsilon_1, \epsilon_2) = \frac{\epsilon_1 + \epsilon_2}{2} + \frac{|\epsilon_1 - \epsilon_2|}{2}$ with $\epsilon_1 - \epsilon_2 \sim \mathcal{N}(0, 2\sigma^2)$ and $\mathbb{E}|\cdot| = \sqrt{2\sigma^2}\sqrt{2/\pi}$, so $\mathbb{E}\max = \sigma/\sqrt\pi \approx 0.56\sigma$; it grows with $K$ (roughly $\sigma\sqrt{2\log K}$). (b) The true value is 0, so the expected overconfidence is $\sigma/\sqrt\pi > 0$ even though every individual estimate is unbiased. (c) More data means a smaller error in $\hat P$ (a smaller $\sigma$), hence a smaller overestimate: +0.260 with 3 episodes → +0.009 with 100. Remedies: cross-fitting (choose the action with one half of the data, evaluate it with the other — the idea behind Double Q-learning), or pessimism where uncertainty is high (offline RL, CS234 Lecture 10).

练习 4（Scalar LQR）. $s_{t+1} = s_t + a_t$，代价 $\sum_t(s_t^2 + \rho a_t^2)$。(a) 求稳态 Riccati 方程的解 $p$ 和增益 $K$。(b) 讨论 $\rho \to 0$ 和 $\rho \to \infty$ 的极限，并给出直觉。(c) 闭环系统 $s_{t+1} = (1 - K)s_t$ 一定稳定吗？

(a) $A = B = U = 1$，$W = \rho$：$p = 1 + p - \frac{p^2}{\rho + p}$，即 $p^2 = \rho + p$，取正根 $p = \frac{1 + \sqrt{1 + 4\rho}}{2}$；$K = \frac{p}{\rho + p} = \frac{p}{p^2} = \frac1p$。(b) $\rho \to 0$（用力免费）：$p \to 1$，$K \to 1$，一步把状态推到 0（deadbeat control）。$\rho \to \infty$（用力很贵）：$p \approx \sqrt\rho$，$K \approx 1/\sqrt\rho \to 0$，慢慢地、温柔地往回推。代码 04 演示 1 里 $K_t$ 在时域末尾变小是同一个直觉的时间版本：剩下的步数少，“用力”的回报就少。(c) $1 - K = 1 - 1/p \in [0, 1)$，所以一定稳定（单调收敛，不振荡）。

练习 5（Baselines）. (a) 证明对任何只依赖 $s_t$ 的 $b(s_t)$，$\mathbb{E}\big[\nabla_\theta\log\pi_\theta(a_t \mid s_t)\,b(s_t)\big] = 0$。为什么 $b$ 不能依赖 $a_t$？(b) 只考虑一步问题（一个 $\nabla\log\pi$、一个回报 $G$），在所有常数 $b$ 里，使 $\mathbb{E}\lVert\nabla\log\pi\,(G - b)\rVert^2$ 最小的 $b$ 是什么？它和”平均回报”有什么不同？(c) 解释代码 05 里为什么减去 baseline 后 $c = 0$ 和 $c = 1$ 的结果完全相同。