简介：《强化学习的数学原理》是西湖大学赵世钰教授撰写的英文专著，面向具备线性代数、概率论与优化基础的研究生及算法工程师，系统解决强化学习理论理解不深、公式推导不清、算法本质难把握等核心痛点。全书从网格世界等直观示例切入，严格推导贝尔曼方程、值迭代、策略梯度、Actor-Critic等关键方法，并在附录中严谨论证序列收敛性，兼顾数学严谨性与教学可读性。资源为单文件PDF（18.9MB），内容完整覆盖10章主体+附录，含大量图示、矩阵向量形式表达、闭式与迭代解法对比及Q&A环节，便于精读推演与课后自查。目前已有845人学习下载，适合希望夯实RL数学根基、深入理解算法收敛性与设计逻辑的进阶学习者。
1. 强化学习的数学原理：不是“调参玄学”，而是你手里的“决策说明书”
你有没有试过教一个完全没接触过编程的朋友写个“自动走迷宫”的小程序？
他可能很快能画出格子、标出起点终点，但一问“那它怎么知道该往左还是往右走？”，他就卡住了——不是不会写 if 语句，而是根本没想清楚：“知道”这件事，到底靠什么建立？
《强化学习的数学原理》这本书，就是专门来回答这个“靠什么”的。它不教你用哪个库、跑哪个开源项目、调哪三个超参数让准确率涨 0.3%；它从第一页开始就带着你拆解：当一个智能体（比如迷宫里的小机器人）在环境中一步步试探、犯错、拿奖励、记教训时，背后支撑它“越试越聪明”的那套逻辑，到底是怎么被写成数学语言的？
它讲的不是“黑匣子怎么输出结果”，而是“黑匣子内部的齿轮怎么咬合”。比如：为什么我们非得用“折扣回报”而不是简单加总所有奖励？贝尔曼方程那个看着像绕口令的等式，其实是在说一句大白话：“一个状态的好坏，等于它立刻拿到的奖励，加上它下一步最可能去的那个状态的好坏（打个折）”——而这本书，会带你亲手推一遍这句话怎么变成公式、又怎么变成可计算的数字。
它适合谁？
✅ 完全没听过“MDP”“策略梯度”“TD误差”的零基础同学；
✅ 跟着教程跑通了 DQN 小游戏，但看到论文里一行偏导数就头皮发紧的实践者；
✅ 学过概率论和线性代数，但不确定这些知识怎么“派上用场”的本科生/转行者。
它不要求你会写 PyTorch，但要求你愿意拿起笔，在草稿纸上把一个 3×3 网格世界的状态转移概率列成矩阵；它不回避数学符号，但每个符号出现前，一定先给你一个格子图、一次模拟轨迹、一个手算的小例子。这不是一本“速成手册”，而是一份陪你从“我试试看”走到“我明白了”的学习地图——而这张地图的起点，就藏在第一章那个最朴素的网格世界里。
2. 先搞懂一个概念：强化学习到底在解决什么问题？
强化学习不是“AI 自己学”，而是“人给 AI 定规则，AI 在规则里找最优解”。这个“规则”就是环境，“最优解”就是策略。要真正看懂这本书，得先放下“AI 很神奇”的预设，回到最原始的交互现场：一个智能体（Agent），在一个环境（Environment）里，通过不断做动作（Action），观察状态（State）变化，获得奖励（Reward），最终学会一套“在什么情况下该做什么”的行为逻辑。这整套闭环，就是强化学习要建模的对象。
2.1 从网格世界出发：一个能画在纸上的“小宇宙”
书里第一章开篇就扔给你一个 4×3 的网格世界（图 1.1）。它只有 12 个格子，其中一个是起点（S），一个是终点（G），还有两个是陷阱（X）。智能体每次只能上下左右移动一格（动作空间 A = {↑, ↓, ←, →}），但移动不一定成功——比如在边缘格子往墙外走，就会原地不动。每走一步，它得到 -1 分；掉进陷阱，得 -100 分；到达终点，得 +10 分。目标？用最少步数、最高总分走到 G。
提示：别急着想“怎么编程实现”，先在纸上画出来。标出每个格子的坐标，手动模拟三次：从 S 出发，随机选方向走，记录每一步的 state、action、reward、next_state。你会发现，即使规则极简，路径选择也立刻变得不 trivial——有些路看似近，但靠近陷阱；有些路绕远，却稳赚不赔。这种“当前选择影响未来收益”的张力，就是强化学习存在的全部理由。
这个小世界，就是全书所有数学工具的“试验田”。后面每一章的公式、算法、证明，都会回到这里：用它解释贝尔曼方程怎么算一个格子的“价值”，用它演示值迭代如何一步步更新整个网格的价值表，用它对比蒙特卡洛和时间差分在采样效率上的差异。它不是玩具，而是锚点——当你被一堆符号绕晕时，只要回到这个 4×3 的格子，一切就重新有了坐标。
2.2 四个核心要素：State、Action、Reward、Policy，缺一不可
强化学习的骨架，由四个基本概念撑起。它们不是抽象术语，而是对上述网格世界中真实发生事件的精准翻译：
State（状态）：环境在某一刻的完整快照。在网格世界里，就是一个坐标 (i,j)；在下棋中，是当前棋盘所有棋子的位置；在自动驾驶里，是车辆位置、速度、周围车距、红绿灯状态等传感器数据的组合。关键点：状态必须包含所有影响未来决策的信息。如果只告诉智能体“我在第2行”，却不告诉它“左边是墙”，那它就无法判断←是否安全——这个“不完整”的描述，就不构成合法状态。
Action（动作）：智能体能主动执行的操作。在网格世界里是四个方向；在推荐系统里是“推给用户哪条视频”；在机器人控制里是“关节扭矩大小”。注意：动作必须是环境能响应的。你不能在网格世界里定义动作 “瞬移”，因为环境没有这个接口。
Reward（奖励）：环境对动作的即时反馈。它是强化学习唯一的“老师”。-1 分告诉你“这步没用”，+10 分告诉你“到终点了”，-100 分是严厉警告。但奖励设计是门手艺：如果只给终点+10，中间全0，智能体可能永远学不会“避开陷阱”，因为它没收到任何关于“靠近陷阱很危险”的信号。书中 1.5 节专门用表格对比了不同奖励设计对学习效果的影响。
Policy（策略）：状态到动作的映射规则。可以是确定性的（π(s) = ↑），也可以是随机的（π(↑|s)=0.7, π(→|s)=0.3）。它是智能体的“大脑”，也是我们最终想优化的目标。注意：策略不是固定程序，而是可学习的函数。值迭代、策略梯度等所有算法，本质都是在寻找一个能让长期奖励期望值最大的策略。
这四个要素串起来，就是一条轨迹（Trajectory）：s₀ → a₀ → r₁ → s₁ → a₁ → r₂ → s₂ → … → sₜ。而一次从起点到终点（或掉陷阱/超时）的完整轨迹，就是一个Episode（回合）。所有强化学习算法，都在这条轨迹产生的数据上做文章。
2.3 马尔可夫决策过程（MDP）：给“决策”装上数学保险栓
你可能会问：既然状态包含了所有信息，那下一个状态 s₁，是不是只取决于当前状态 s₀ 和动作 a₀？比如在网格世界，站在 (2,2) 格子，选↑，下一格一定是 (1,2)，跟昨天吃了什么、上一步怎么来的都没关系——这就是马尔可夫性（Markov Property）。
MDP 就是把这种“无记忆依赖”形式化：它定义了一个五元组 (S, A, P, R, γ)，其中：
- S：状态集合（如 {(1,1), (1,2), ..., (4,3)}）
- A：动作集合（{↑, ↓, ←, →}）
- P：状态转移概率函数，P(s′|s,a) 表示在 s 执行 a 后到达 s′ 的概率。在确定性网格世界里，这个值要么是 0 要么是 1；在有滑动风险的冰面世界里，它可能是 P((2,2)|(2,1),→)=0.8（80% 成功，20% 原地打滑）。
- R：奖励函数，R(s,a,s′) 表示在 s 执行 a 到达 s′ 时获得的奖励。也可简写为 R(s,a)，假设奖励只与当前状态动作有关。
- γ：折扣因子（0≤γ<1），用来权衡“眼前利益”和“长远收益”。γ=0 只看下一步，γ=0.99 就像一个很有耐心的投资者。
提示：γ 不是随便选的超参数！书中 2.2 节用一个两步决策的例子直白说明：如果 γ 太小（如 0.1），智能体宁愿拿眼前 -1 分也不愿冒险走两步去拿 +10 分；如果 γ 太大（如 0.999），它可能为了一分之差，在陷阱边缘反复试探。γ 的选择，本质上是在“规避风险”和“追求最优”之间划一条线。
MDP 的意义，是把模糊的“智能决策”转化成一个可建模、可求解、可证明的数学对象。后续所有算法——值迭代、Q-learning、策略梯度——都是在 MDP 框架下，针对不同假设（是否知道 P 和 R？能否重置环境？）设计的求解器。它不是束缚，而是护栏：确保你在探索“怎么聪明”之前，先确认“聪明”本身有清晰的定义。
2.4 常见问题排查：新手最容易卡在哪儿？
刚接触 MDP 描述时，几乎所有人都会踩这几个坑，我第一次手推贝尔曼方程时也翻过车：
现象：列出状态转移概率 P(s′|s,a) 时，发现某一行加起来不等于 1。
原因：漏掉了“原地不动”的情况。比如在 (1,1)（左上角）执行 ←，按规则应该卡在原地，但你只写了 P((1,1)|(1,1),←)=0，忘了补上 P((1,1)|(1,1),←)=1。
解决：对每个 (s,a) 组合，强制检查 ∑_{s′∈S} P(s′|s,a) == 1。不等于 1？回头重读环境规则，找那个“失败后去哪”的默认分支。现象：计算某个状态的期望奖励时，结果是个负数，但直觉上它离终点很近，应该“值钱”。
原因：混淆了 R(s,a,s′) 和 R(s,a)。在网格世界，R(s,a,s′) 只在 s′ 是终点或陷阱时非零；其他时候，无论你从哪来、往哪去，走一步就是 -1。如果你错误地把 R(s,a,s′) 当成“到达 s′ 的奖励”，就会漏掉这 -1。
解决：严格按定义写：R(s,a,s′) = -1 （对所有普通转移），+10（s′=G），-100（s′=X）。然后在贝尔曼方程里，它自然会出现在求和项里。现象：看到“策略 π 是一个函数”，就试图用 if-else 写死所有状态的动作，结果代码巨长且无法泛化。
原因：把“策略”误解为“查表指令”，而忽略了它本质是一个可参数化的函数族。π(a|s) 可以是 softmax(wᵀϕ(s))，可以是神经网络输出的概率分布。查表只是最原始的实现方式。
解决：先用表格实现（第 4 章），理解逻辑；再过渡到函数近似（第 8 章）。记住：策略的终极形态，是能压缩成几个参数的数学表达式，不是一张铺满内存的巨表。现象：读到“episode 是一次完整交互”，就认为必须从起点跑到终点才算一个 episode，导致在无限状态空间里卡死。
原因：忽略了 episode 的终止条件可以人为设定。在连续控制任务（如机械臂）中，常设最大步数 T=1000，到步就截断；在对话系统中，用户说“再见”就是 episode 结束。
解决：明确你的任务中 episode 的边界是什么。书里所有网格世界例子都用“到达 G 或 X 或步数超限”三条件终止，这是最安全的起点。
3. 贝尔曼方程：把“值多少钱”翻译成可计算的数学语言
如果说 MDP 是强化学习的宪法，那贝尔曼方程就是它的基本法。它不做任何新规定，只是把“状态价值”这个直觉概念，用数学语言严谨地“翻译”出来。很多新手觉得它绕，是因为没意识到：它根本不是发明新东西，而是在给“常识”写定义。比如，我们说“站在起点 S 的价值是 5”，这句话到底意味着什么？贝尔曼方程就负责把这个“5”拆解成：S 这一步拿的奖励，加上从 S 能去的所有地方的价值（按概率加权，再打个折）。
3.1 状态价值 Vπ(s)：不是“此刻多好”，而是“未来有多稳”
先明确一个关键区分：状态价值（State Value）Vπ(s)和动作价值（Action Value）Qπ(s,a)。前者问：“如果我现在在状态 s，并一直按策略 π 行动，我未来能拿到多少总奖励（期望值）？”后者问：“如果我现在在状态 s，先强行做动作 a，之后再按策略 π 行动，我能拿到多少总奖励（期望值）？”
在网格世界里，Vπ(S) 告诉你：从起点出发，按当前策略走，平均能得多少分；Qπ(S,↑) 告诉你：从起点先往上走一步，之后再按策略走，平均能得多少分。显然，Qπ 包含了更细粒度的决策信息——它直接告诉你“↑ 这步值不值”。
书中 2.3 节定义 Vπ(s) = Eπ[Gₜ | Sₜ=s]，其中 Gₜ 是从时刻 t 开始的折扣回报：Gₜ = Rₜ₊₁ + γRₜ₊₂ + γ²Rₜ₊₃ + ...。这个定义本身很抽象，但结合网格世界就立刻落地：假设策略 π 规定在 S 总是↑，那么 G₀ 就是 R₁（第一步奖励）+ γ·R₂（第二步奖励）+ γ²·R₃ + ...，直到到达 G 或 X。Vπ(S) 就是所有可能轨迹的 G₀ 的平均值。
提示：初学者常误以为 Vπ(s) 是“最优路径的回报”。错！它是按当前策略 π 所有可能路径的期望回报。如果 π 是随机乱走，Vπ(S) 可能是负几百；如果 π 是最优策略，Vπ(S) 才接近理论最大值。Vπ 是策略的“体检报告”，不是“冠军证书”。
3.2 贝尔曼方程：一个状态的价值，等于它“当下所得”加“未来所期”
现在，把 Vπ(s) 的定义展开。根据全期望公式，我们可以把“从 s 开始的期望回报”，拆成两部分：
- 当下所得：在 s 执行动作 a（按 π 选择），立刻拿到的奖励 R(s,a,s′)；
- 未来所期：到达新状态 s′ 后，从 s′ 开始继续按 π 行动的期望回报，即 Vπ(s′)。
把这两部分用概率加权、再乘上折扣因子 γ，就得到贝尔曼方程的核心形式：
Vπ(s) = Σₐ π(a|s) · Σₛ′ P(s′|s,a) · [ R(s,a,s′) + γ · Vπ(s′) ]
这个公式看起来复杂，但回到网格世界，它就是一句大白话：
“起点 S 的价值 = （选↑的概率）×[（↑成功到 (1,2) 的概率）×（-1 + γ×Vπ(1,2)） + （↑失败卡在 S 的概率）×（-1 + γ×Vπ(S)）]
- （选↓的概率）×[... ] + ... ”
它把一个全局的、似乎需要穷尽所有路径才能算的价值，转化成了一个局部的、只和邻居状态有关的方程。这意味着：只要我知道所有邻居 s′ 的 Vπ(s′)，我就能算出 s 的 Vπ(s)。而所有邻居的 Vπ，又依赖于它们的邻居……最终，整个网格的价值，被锁在一个相互关联的方程组里。
3.3 矩阵-向量形式：把 12 个方程打包成一次运算
对 4×3 网格世界，我们有 12 个状态，对应 12 个贝尔曼方程。手工解太慢，但用线性代数可以秒杀。书中 2.6 节把它写成：
Vπ = Rπ + γ · Pπ · Vπ
其中：
- Vπ 是 12×1 的列向量，每个元素是 Vπ(sᵢ)；
- Rπ 是 12×1 的列向量，Rπ(i) = Σₐ π(a|sᵢ) · Σₛ′ P(s′|sᵢ,a) · R(sᵢ,a,s′)，即状态 sᵢ 的期望即时奖励；
- Pπ 是 12×12 的矩阵，Pπ(i,j) = Σₐ π(a|sᵢ) · P(sⱼ|sᵢ,a)，即从 sᵢ 按 π 行动后到达 sⱼ 的总概率。
这个式子移项一下：(I - γ·Pπ) · Vπ = Rπ，立刻变成标准线性方程组 Ax=b。只要矩阵 (I - γ·Pπ) 可逆（γ<1 时总成立），就能用np.linalg.solve(A, b)一次性解出所有 Vπ(s)。这就是“闭式解”（2.7.1 节）——它不迭代，不采样，纯数学暴力破解。
提示：这个矩阵解法只适用于“小规模、已知模型”的场景（如书中的网格世界）。一旦状态空间变大（比如围棋的 10¹⁷⁰ 个状态），矩阵就存不下，更别说求逆了。这时就必须用“迭代解”（2.7.2 节）：从任意初始 V⁰ 开始，反复代入 V^{k+1}(s) = Σₐ π(a|s) Σₛ′ P(s′|s,a)[R(s,a,s′)+γ·Vᵏ(s′)]，直到收敛。这就像用望远镜一点点校准焦距，虽然慢，但内存友好。
3.4 从 Vπ 到 Qπ：价值的“显微镜”视角
Vπ(s) 告诉你“在 s 这里整体好不好”，但没告诉你“具体哪一步动作最好”。Qπ(s,a) 就是这个显微镜。书中 2.8 节给出其定义：
Qπ(s,a) = Σₛ′ P(s′|s,a) · [ R(s,a,s′) + γ · Σₐ′ π(a′|s′) · Qπ(s′,a′) ]
这个式子和 Vπ 的贝尔曼方程神似，区别在于：Vπ 对动作 a 求了期望（Σₐ π(a|s)），而 Qπ 把 a 固定下来，只对下一状态 s′ 和后续动作 a′ 求期望。它揭示了一个关键事实：Qπ(s,a) 的值，不仅取决于 (s,a) 这一对，还取决于 s′ 上所有可能动作的 Qπ 值的加权平均。
为什么这很重要？因为最优策略 π* 的定义，就是让每个 s 的 Qπ*(s,a) 最大的那个 a。即：π*(s) = argmaxₐ Qπ*(s,a)。所以，一旦我们算出了 Qπ*(s,a)，最优策略就呼之欲出——不需要再设计复杂的搜索，直接查表取最大值即可。第 3 章的贝尔曼最优方程（BOE），就是把“argmax”塞进 Qπ 的贝尔曼方程里，得到：
Q(s,a) = Σₛ′ P(s′|s,a) · [ R(s,a,s′) + γ · maxₐ′ Q(s′,a′) ]**
这个方程不再依赖策略 π，只依赖环境本身（P,R），它的解 Q* 就是“上帝视角”的终极价值表。后续所有算法（值迭代、Q-learning）的目标，就是逼近这个 Q*。
3.5 常见问题排查：算贝尔曼方程时，哪些细节会悄悄毁掉结果？
贝尔曼方程是强化学习的基石，但新手在手算或编码时，常因几个“小数点级”的疏忽，导致结果全盘崩溃：
现象：用矩阵法解 Vπ，得到的值全是 NaN 或无穷大。
原因：γ 设成了 1.0。此时 (I - γ·Pπ) 的行列式为 0，矩阵奇异，无法求逆。数学上，γ=1 意味着“永不打折”，在有环的环境中（如网格世界里可能来回走），回报 Gₜ 可能发散（无限循环拿 -1 分）。
解决：γ 必须严格小于 1。书中所有例子用 γ=0.9；实践中，0.95~0.99 是安全区间。检查代码：gamma = 0.99，不是gamma = 1。现象：迭代法计算 Vπ，数值震荡不收敛，或者收敛到明显错误的值（如所有 Vπ(s) 都是 -1000）。
原因：忘记在每次迭代中，用旧的 Vᵏ 计算新的 Vᵏ⁺¹，而不是边算边覆盖。错误写法：V[s] = ... + gamma * V[next_s]（此时 V[next_s] 已被更新）；正确写法：V_new[s] = ... + gamma * V_old[next_s]，一轮算完再整体赋值。
解决：始终维护两个数组：V_old和V_new。书中 2.7.2 节伪代码明确写出V_{k+1}(s) ← ... V_k(s')，箭头表示“读旧值，写新值”。现象：计算 Qπ(s,a) 时，结果比 Vπ(s) 还小，违反直觉（因为 Qπ 应该是 Vπ 的“细化”）。
原因：混淆了 Qπ 的定义域。Qπ(s,a) 是“先做 a，再按 π”，而 Vπ(s) 是“直接按 π”。如果 π(s) 恰好不是 a，那么 Qπ(s,a) 可能很差（比如在 S，π 规定↑，但你算 Qπ(S,←)，就是往墙里撞）。
解决：验证时，只比较 Qπ(s, π(s)) 和 Vπ(s)，二者应相等（由定义可证）。若不等，检查 P 和 R 的索引是否错位。现象：矩阵 Pπ 的维度不对，12×12 的矩阵乘出来不是 12×1，而是报错。
原因：Pπ 的构建逻辑错误。Pπ(i,j) 应该是“从状态 i 出发，按 π 行动，到达状态 j 的概率”。新手常写成 Pπ(i,j) = P(sⱼ|sᵢ, aᵢ)，即固定了每个 sᵢ 的动作 aᵢ，但 π 是概率分布，必须对所有 a 求和：Pπ(i,j) = Σₐ π(a|sᵢ) · P(sⱼ|sᵢ,a)。
解决：用双重循环：外层遍历 sᵢ，内层遍历所有 a，累加 π(a|sᵢ)*P(sⱼ|sᵢ,a) 到 Pπ[i][j]。打印 Pπ 的几行，手动验算：每行之和是否为 1？
4. 值迭代与策略迭代：两种逼近“上帝视角”的实战路径
有了贝尔曼方程，我们知道“最优价值 Q* 应该满足什么”，但怎么找到它？值迭代（Value Iteration）和策略迭代（Policy Iteration）就是两条经典路径。它们不是竞争关系，而是同一目标下的两种工程策略：值迭代像一个谨慎的勘探者，一步步逼近 Q*；策略迭代像一个果敢的建筑师，先搭个粗糙框架（策略），再精雕细琢（改进策略）。书中第 4 章用网格世界全程演示，你会发现，它们最终抵达的是同一个山顶，只是脚印不同。
4.1 值迭代：用“最大值”代替“期望值”，直接攻向 Q*
值迭代的核心思想，极其朴素：既然最优 Q满足 Q(s,a) = Σₛ′ P(s′|s,a)[R(s,a,s′)+γ·maxₐ′ Q*(s′,a′)]，那我就用当前最好的 Qᵏ 来估计右边的 maxₐ′ Q*(s′,a′)，然后更新 Qᵏ⁺¹**。伪代码（4.1.1 节）就三行：
Initialize Q⁰(s,a) arbitrarily Repeat until convergence: For each s,a: Q^{k+1}(s,a) ← Σₛ′ P(s′|s,a) [ R(s,a,s′) + γ · maxₐ′ Qᵏ(s′,a′) ]注意关键点：右边用的是maxₐ′ Qᵏ(s′,a′)，不是Σₐ′ π(a′|s′) Qᵏ(s′,a′)。这意味着值迭代完全不依赖任何策略 π，它直接在价值空间里“爬山”，每一步都贪婪地朝当前能看到的最高点（max）迈进。这带来两个好处：1）无需初始化策略；2）更新方向永远指向最优，不会陷入局部陷阱。
在网格世界里实操：初始化所有 Q⁰(s,a)=0。第一轮，对每个 (s,a)，计算它一步能到的所有 s′ 的maxₐ′ Q⁰(s′,a′)（此时全为 0），所以 Q¹(s,a) ≈ R(s,a,s′)。那些能直达 G 的动作（如 G 左边格子的 →），Q¹ 就是 +10；能直达 X 的，就是 -100；其他都是 -1。第二轮，Q² 就会考虑“-1 + γ·10”这样的组合，价值开始向 G 渗透……十轮之后，Q¹⁰ 的数值已经清晰勾勒出通往终点的“价值梯度”。
提示：值迭代的收敛性由“收缩映射”保证（3.3.3 节）。直观理解：每次更新，Qᵏ 和 Q* 的差距至少缩小 γ 倍。所以误差界是 ||Qᵏ - Q*|| ≤ γᵏ / (1-γ) · ||Q⁰ - Q¹||。想快速收敛？提高 γ（但别到 1）；想稳定？多迭代几轮。书中 4.1.2 节用一个 2 状态 MDP 手算 5 步，误差从 10 降到 0.001，非常震撼。
4.2 策略迭代：先“大胆假设”，再“小心求证”
策略迭代则换了一种思路：它承认“直接算 Q* 太难”，于是分两步走：
- 策略评估（Policy Evaluation）：给定一个策略 πᵏ，精确计算它的价值 Vπᵏ（用贝尔曼方程迭代或矩阵法）；
- 策略提升（Policy Improvement）：基于 Vπᵏ，构造一个更好的策略 πᵏ⁺¹：对每个 s，选能让 Qπᵏ(s,a) 最大的 a，即 πᵏ⁺¹(s) = argmaxₐ Σₛ′ P(s′|s,a)[R(s,a,s′)+γ·Vπᵏ(s′)]。
这个过程（4.2.1 节）保证：πᵏ⁺¹ 严格优于 πᵏ（除非 πᵏ 已是最优）。因为对每个 s，新策略选的动作，其 Q 值 ≥ 旧策略所有动作的 Q 值平均（即 Vπᵏ(s)），所以 Vπᵏ⁺¹(s) ≥ Vπᵏ(s)，且至少在一个 s 严格大于。
在网格世界，策略迭代往往比值迭代更快收敛。比如，初始策略 π⁰ 是随机的（每个 s 等概率选四个方向）。策略评估后，发现 S 的 Vπ⁰(S) 是 -50（乱走太惨）；策略提升时，对 S 计算 Qπ⁰(S,↑)、Qπ⁰(S,↓)… 发现 ↑ 的 Q 值最高（-1 + 0.9×Vπ⁰(1,2) > 其他），于是 π¹(S)=↑。几轮之后，策略就稳定在最优路径上。
提示：策略迭代的“评估”步骤，可以用迭代法（慢但省内存）或矩阵法（快但需存矩阵）。书中 4.2.2 节给出元素级实现，强调
V_{k+1}(s) ← Σₐ πᵏ(a|s) Σₛ′ P(s′|s,a)[R(s,a,s′)+γ·V_k(s′)]，再次提醒：用V_k，不是V_{k+1}。
4.3 截断策略迭代：工程人的“够用就好”哲学
纯策略迭代有个软肋：策略评估要等 Vπᵏ 完全收敛（误差 < ε），这在大规模问题中耗时太久。截断策略迭代（Truncated Policy Iteration，4.3 节）就是对此的务实妥协：策略评估只做固定次数（如 1~3 次）迭代，就停止并进入策略提升。它牺牲了“理论最优性”，换来了“实践高效性”。
这背后是深刻的工程洞察：我们并不需要 Vπᵏ 的精确值，只需要它足够好，能让我们选出一个比 πᵏ 更好的策略 πᵏ⁺¹ 即可。实验表明（4.3.1 节），做 1 次评估 + 1 次提升，效果往往接近完整策略迭代，但速度提升数倍。这正是深度强化学习中“Actor-Critic”架构的雏形：Critic（价值网络）只做粗略评估，Actor（策略网络）据此快速更新。
在代码中实现截断策略迭代，只需把策略评估的 while 循环，改成 for 循环for i in range(3):。书中 4.3.2 节的算法框图清晰标注了这个“截断点”。
4.4 常见问题排查：值迭代 vs 策略迭代，选错就像选错登山路线
新手常纠结“该用哪个”，其实答案很简单：从小规模、已知模型的问题起步，用策略迭代（收敛快、易调试）；从大规模、未知模型的问题起步，用值迭代（结构简单、易扩展）。但实操中，几个细节决定成败：
现象：值迭代的 Q 值在后期震荡，不收敛。
原因：γ 太大（如 0.999）且状态空间有环，导致数值误差累积放大。或者，maxₐ′ Qᵏ(s′,a′)计算时，多个 a′ 的 Qᵏ 值非常接近，浮点精度下取 max 不稳定。
解决：降低 γ（0.9~0.95）；或在 max 前加小扰动：maxₐ′ (Qᵏ(s′,a′) + eps * np.random.randn())；或改用“soft-max”近似 max。现象：策略迭代的策略提升后，Vπᵏ⁺¹(s) 反而比 Vπᵏ(s) 小。
原因：策略提升时，计算argmaxₐ Qπᵏ(s,a)用的是近似 Vπᵏ（未完全收敛），而 Qπᵏ(s,a) = Σₛ′ P(s′|s,a)[R(s,a,s′)+γ·Vπᵏ(s′)]。如果 Vπᵏ 误差大，Q 估计就错，选的 a 就未必真好。
解决：确保策略评估足够充分（误差 < 0.01）；或改用“ε-greedy 提升”：以 1-ε 概率选 max，ε 概率随机，增加鲁棒性。现象：截断策略迭代收敛到次优策略，且无法改进。
原因：截断次数太少（如只做 1 次评估），Vπᵏ 太粗糙，导致策略提升选错了方向。
解决：动态调整截断次数：初期多些（3~5 次），后期少些（1~2 次）；或监控 Vπᵏ 的变化率，下降慢时自动增加评估轮数。现象：两种算法在相同网格世界，算出的最优动作不一致。
原因：最优策略不唯一！在某些状态，多个动作的 Q* 值相等（如对称路径）。算法随机性（如 max 时遇到并列）会导致不同选择。这不是 bug，而是 MDP 的固有性质。
解决：接受多解性；或在 argmax 时加入确定性规则（如“并列时选编号最小的动作”）。
5. 从“知道模型”到“不知道模型”：蒙特卡洛与时间差分的破壁之旅
前面四章的算法（值迭代、策略迭代）都有一个隐藏前提：我们知道环境的完整模型——即 P(s′|s,a) 和 R(s,a,s′) 的所有数值。这在网格世界里可行（我们亲手定义了规则），但在真实世界中，这相当于要求 AI 先把物理定律、所有传感器噪声、人类反应模式全部写成公式——显然不现实。第 5 章（蒙特卡洛）和第 7 章（时间差分
本文还有配套的精品资源，点击获取
