强化学习基础¶

强化学习（Reinforcement Learning, RL）是机器学习的一种范式，智能体通过与环境交互学习做出序贯决策，以最大化累积奖励。与监督学习不同，RL 不需要标注的输入-输出对——相反，智能体通过试错来发现最优行为。RL 是游戏 AI（AlphaGo、OpenAI Five）、机器人控制、自动驾驶和大语言模型对齐（RLHF）背后的数学框架。

本章涵盖支撑所有 RL 算法的理论基础，遵循 Sutton & Barto（2018）的经典教材 Reinforcement Learning: An Introduction 的结构。

学习目标¶

完成本章后，你将能够：

定义智能体-环境接口并解释 RL 的关键组件
将问题形式化为马尔可夫决策过程（Markov Decision Process, MDP）
推导并解释值函数的贝尔曼方程（Bellman Equations）
实现动态规划方法（策略迭代、价值迭代）
理解蒙特卡洛方法和时序差分学习
比较不同的 RL 范式（无模型 vs. 基于模型，在线策略 vs. 离线策略）
使用 Python 和 Gymnasium 构建和求解 RL 环境
将 RL 基础知识与机器人操作和控制任务联系起来

1. 什么是强化学习？¶

1.1 智能体-环境接口¶

RL 的核心思想很简单：一个**智能体（Agent）在**环境（Environment）**中执行**动作（Action），观察**状态（State）和**奖励（Reward），并学习一个**策略（Policy）**来最大化长期奖励。

  +------------+    action a_t    +--------------+
  |            | ----------------->|              |
  |   Agent    |                  | Environment  |
  |            |<---------------- |              |
  +------------+  state s_{t+1}   +--------------+
       ^          reward r_t           |
       |                               |
       +-------------------------------+

在每个时间步 \(t\)：

智能体观察当前状态 \(s_t \in \mathcal{S}\)
智能体根据策略 \(\pi\) 选择动作 \(a_t \in \mathcal{A}(s_t)\)
环境转移到新状态 \(s_{t+1} \sim P(\cdot | s_t, a_t)\)
智能体接收奖励 \(r_{t+1} = R(s_t, a_t, s_{t+1})\)
智能体更新策略以最大化期望累积奖励

1.2 RL vs. 监督学习 vs. 无监督学习¶

方面	监督学习	无监督学习	强化学习
数据	标注对 \((x, y)\)	无标注数据 \(x\)	序贯 \((s, a, r, s')\)
反馈	正确标签	结构/模式	标量奖励信号
目标	最小化预测误差	发现隐藏结构	最大化累积奖励
时序性	独立样本	独立样本	序贯决策
探索	不需要	不需要	必不可少
示例	分类、回归	聚类、PCA	游戏、机器人

1.3 历史与关键里程碑¶

年份	里程碑	关键贡献
1950s	动态规划（Dynamic Programming, Bellman）	数学基础
1989	Q-Learning（Watkins）	无模型离线策略控制
1992	TD-Gammon（Tesauro）	自博弈西洋双陆棋
2013	DQN（DeepMind）	深度 RL 玩 Atari
2016	AlphaGo（DeepMind）	超人类围棋
2017	PPO（OpenAI）	稳定的策略优化
2019	OpenAI Five	多智能体 Dota 2
2022	ChatGPT（RLHF）	RL 用于语言模型对齐

2. 多臂老虎机¶

在深入完整的 MDP 之前，我们研究 k 臂老虎机（k-Armed Bandit） 问题——最简单的 RL 设置，只有一个状态和 \(k\) 个动作。

2.1 k 臂老虎机问题¶

你面对 \(k\) 台老虎机（臂），每台有未知的奖励分布。每一步，你拉动一个臂并获得奖励。目标：在 \(T\) 步内最大化总奖励。

形式化地，每个臂 \(a\) 有一个真实值 \(q_*(a) = \mathbb{E}[R_t | A_t = a]\)。最优动作是 \(a^* = \arg\max_a q_*(a)\)。

2.2 动作值方法¶

使用样本均值估计 \(Q_t(a) \approx q_*(a)\)：

\[Q_t(a) = \frac{\sum_{i=1}^{t-1} R_i \cdot \mathbb{1}_{A_i = a}}{\sum_{i=1}^{t-1} \mathbb{1}_{A_i = a}}\]

选择动作：\(A_t = \arg\max_a Q_t(a)\)（贪心）。

2.3 探索与利用¶

根本性的困境：**利用（Exploit）**当前最优的臂，还是**探索（Explore）**以找到更好的臂？

\(\epsilon\)-贪心（\(\epsilon\)-Greedy）：以概率 \(\epsilon\) 随机选择；否则贪心选择。

\[A_t = \begin{cases} \text{random action} & \text{with probability } \epsilon \\ \arg\max_a Q_t(a) & \text{with probability } 1 - \epsilon \end{cases}\]

置信上界（Upper Confidence Bound, UCB）：

\[A_t = \arg\max_a \left[ Q_t(a) + c \sqrt{\frac{\ln t}{N_t(a)}} \right]\]

其中 \(c\) 控制探索-利用的权衡。

汤普森采样（Thompson Sampling）：维护每个臂值的后验分布；从后验中采样并贪心地行动。

import numpy as np
import matplotlib.pyplot as plt

def run_bandit_experiment(k=10, steps=1000, epsilon=0.1, runs=200):
    """Compare epsilon-greedy strategies on a k-armed bandit testbed."""
    avg_rewards = np.zeros((runs, steps))
    optimal_counts = np.zeros((runs, steps))

    for run in range(runs):
        # True values: q*(a) ~ N(0, 1)
        q_star = np.random.randn(k)
        best_action = np.argmax(q_star)
        Q = np.zeros(k)       # Estimated values
        N = np.zeros(k)       # Action counts

        for t in range(steps):
            # epsilon-greedy action selection
            if np.random.random() < epsilon:
                action = np.random.randint(k)
            else:
                action = np.argmax(Q)

            # Reward: R ~ N(q*(a), 1)
            reward = q_star[action] + np.random.randn()
            N[action] += 1
            Q[action] += (reward - Q[action]) / N[action]

            avg_rewards[run, t] = reward
            if action == best_action:
                optimal_counts[run, t] = 1

    return avg_rewards.mean(axis=0), optimal_counts.mean(axis=0) * 100

# Compare epsilon = 0, 0.01, 0.1
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
for eps, label in [(0, 'eps=0 (greedy)'), (0.01, 'eps=0.01'), (0.1, 'eps=0.1')]:
    rewards, optimal = run_bandit_experiment(epsilon=eps)
    ax1.plot(rewards, label=label)
    ax2.plot(optimal, label=label)

ax1.set_xlabel('Steps'); ax1.set_ylabel('Average Reward'); ax1.legend()
ax2.set_xlabel('Steps'); ax2.set_ylabel('% Optimal Action'); ax2.legend()
ax1.set_title('10-Armed Bandit: Average Reward')
ax2.set_title('10-Armed Bandit: % Optimal Action')
plt.tight_layout(); plt.savefig('bandit_comparison.png', dpi=150); plt.show()

3. 马尔可夫决策过程（MDP）¶

MDP 是 RL 的形式化数学框架。几乎所有 RL 问题都可以被表述为 MDP。

3.1 马尔可夫性质¶

状态 \(s_t\) 具有**马尔可夫性质（Markov Property）**，当且仅当：

\[P(s_{t+1} | s_t, a_t, s_{t-1}, a_{t-1}, \ldots) = P(s_{t+1} | s_t, a_t)\]

未来仅取决于现在，而不取决于历史。这就是"无记忆"性质。

3.2 形式化定义¶

MDP 是一个五元组 \((\mathcal{S}, \mathcal{A}, P, R, \gamma)\)：

符号	含义	机器人示例
\(\mathcal{S}\)	状态空间	关节角度 + 速度
\(\mathcal{A}\)	动作空间	关节力矩
\(P(s' \mid s, a)\)	转移概率	物理动力学
\(R(s, a, s')\)	奖励函数	任务完成信号
\(\gamma \in [0,1)\)	折扣因子	我们对远期奖励的重视程度

3.3 回报与折扣因子¶

从时间 \(t\) 开始的**回报（Return）**是累积折扣奖励：

\[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}\]

\(\gamma = 0\)：短视（只关心即时奖励）
\(\gamma \to 1\)：远视（关心未来奖励）
\(\gamma < 1\) 保证有界奖励下 \(G_t\) 是有限的

回报满足递推关系：

\[G_t = R_{t+1} + \gamma G_{t+1}\]

3.4 回合制任务与持续任务¶

类型	描述	示例
回合制（Episodic）	有自然终止状态，然后重置	游戏结束，机器人到达目标
持续制（Continuing）	无终止状态，无限时间域	服务器负载均衡

对于回合制任务，回报是一个有限和：\(G_t = R_{t+1} + \gamma R_{t+2} + \cdots + \gamma^{T-t-1} R_T\)。

4. 值函数¶

值函数估计在给定策略 \(\pi\) 下，处于某个状态（或在某个状态下执行动作）的"好坏程度"。

4.1 状态值函数¶

\[V^\pi(s) = \mathbb{E}_\pi [G_t \mid s_t = s] = \mathbb{E}_\pi \left[\sum_{k=0}^{\infty} \gamma^k R_{t+k+1} \mid s_t = s\right]\]

这是从状态 \(s\) 出发并遵循策略 \(\pi\) 的期望回报。

4.2 动作值函数¶

\[Q^\pi(s, a) = \mathbb{E}_\pi [G_t \mid s_t = s, a_t = a]\]

这是从状态 \(s\) 出发，执行动作 \(a\)，然后遵循策略 \(\pi\) 的期望回报。

\(V\) 和 \(Q\) 之间的关系：

\[V^\pi(s) = \sum_a \pi(a \mid s) Q^\pi(s, a)\]

4.3 贝尔曼方程¶

\(V^\pi\) 的**贝尔曼期望方程（Bellman Expectation Equation）**：

\[V^\pi(s) = \sum_a \pi(a \mid s) \sum_{s'} P(s' \mid s, a) \left[ R(s, a, s') + \gamma V^\pi(s') \right]\]

\(Q^\pi\) 的贝尔曼期望方程：

\[Q^\pi(s, a) = \sum_{s'} P(s' \mid s, a) \left[ R(s, a, s') + \gamma \sum_{a'} \pi(a' \mid s') Q^\pi(s', a') \right]\]

贝尔曼最优方程（Bellman Optimality Equation）：

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

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

    Bellman Expectation Backup          Bellman Optimality Backup

         s                                 s
        /|\                               /|\
       / | \                             / | \
      a1 a2 a3                         a1 a2 a3
      |  |  |                           |  |  |
      s' s' s'                         s' s' s'
      v  v  v                           v  v  v
     V^pi(s')                          max Q*(s',a')
      weighted by pi(a|s)               choose best a

4.4 贝尔曼方程推导¶

从定义出发：

\[V^\pi(s) = \mathbb{E}_\pi [G_t | s_t = s]\]

利用 \(G_t = R_{t+1} + \gamma G_{t+1}\)：

\[V^\pi(s) = \mathbb{E}_\pi [R_{t+1} + \gamma G_{t+1} | s_t = s]\]

对动作和后继状态展开期望：

\[= \sum_a \pi(a|s) \sum_{s'} P(s'|s,a) \left[ R(s,a,s') + \gamma \mathbb{E}_\pi[G_{t+1} | s_{t+1} = s'] \right]\]

\[= \sum_a \pi(a|s) \sum_{s'} P(s'|s,a) \left[ R(s,a,s') + \gamma V^\pi(s') \right]\]

5. 动态规划¶

动态规划（Dynamic Programming, DP）方法在模型 \((P, R)\) 完全已知时求解 MDP。虽然在实际机器人中很少适用（因为动力学未知），DP 为所有 RL 算法提供了概念基础。

5.1 策略评估¶

给定策略 \(\pi\)，通过迭代应用贝尔曼期望方程来计算 \(V^\pi\)：

算法：迭代策略评估（Iterative Policy Evaluation）

Initialize V(s) = 0 for all s in S
Repeat:
    delta <- 0
    For each s in S:
        v <- V(s)
        V(s) <- sum_a pi(a|s) sum_{s'} P(s'|s,a) [R(s,a,s') + gamma*V(s')]
        delta <- max(delta, |v - V(s)|)
Until delta < theta (convergence threshold)

5.2 策略迭代¶

在**评估**（计算 \(V^\pi\)）和**改进**（使 \(\pi\) 对 \(V^\pi\) 贪心）之间交替进行：

策略改进定理（Policy Improvement Theorem）：如果 \(Q^\pi(s, \pi'(s)) \geq V^\pi(s)\) 对所有 \(s\) 成立，则 \(V^{\pi'}(s) \geq V^\pi(s)\) 对所有 \(s\) 成立。

Initialize pi randomly
Repeat:
    1. Policy Evaluation: compute V^pi
    2. Policy Improvement: pi(s) <- argmax_a sum_{s'} P(s'|s,a)[R + gamma*V^pi(s')]
Until pi does not change

5.3 价值迭代¶

将评估和改进合并为单次扫描：

算法：价值迭代（Value Iteration）

Initialize V(s) = 0 for all s in S
Repeat:
    delta <- 0
    For each s in S:
        v <- V(s)
        V(s) <- max_a sum_{s'} P(s'|s,a) [R(s,a,s') + gamma*V(s')]
        delta <- max(delta, |v - V(s)|)
Until delta < theta
Output: pi*(s) = argmax_a sum_{s'} P(s'|s,a) [R(s,a,s') + gamma*V*(s')]

import numpy as np

def value_iteration(grid_size=4, gamma=0.9, theta=1e-6):
    """Solve a grid world using Value Iteration."""
    n_states = grid_size * grid_size
    n_actions = 4  # up, down, left, right
    actions = [(-1,0), (1,0), (0,-1), (0,1)]

    V = np.zeros(n_states)
    policy = np.zeros(n_states, dtype=int)

    def step(state, action):
        row, col = state // grid_size, state % grid_size
        dr, dc = actions[action]
        nr, nc = row + dr, col + dc
        if 0 <= nr < grid_size and 0 <= nc < grid_size:
            next_state = nr * grid_size + nc
        else:
            next_state = state
        reward = -1
        if next_state == n_states - 1:
            reward = 0
        return next_state, reward

    iteration = 0
    while True:
        delta = 0
        for s in range(n_states - 1):
            v = V[s]
            q_values = []
            for a in range(n_actions):
                ns, r = step(s, a)
                q_values.append(r + gamma * V[ns])
            V[s] = max(q_values)
            delta = max(delta, abs(v - V[s]))
        iteration += 1
        if delta < theta:
            break

    for s in range(n_states - 1):
        q_values = []
        for a in range(n_actions):
            ns, r = step(s, a)
            q_values.append(r + gamma * V[ns])
        policy[s] = np.argmax(q_values)

    return V, policy, iteration

V, policy, iters = value_iteration()
print(f"Converged in {iters} iterations")
print("Optimal Value Function:")
print(V.reshape(4, 4).round(2))

5.4 广义策略迭代（GPI）¶

在评估和改进之间交替的思想是几乎所有 RL 算法的核心：

  +----------+         +----------+
  |  Policy   | <-----> |  Policy   |
  |Evaluation |         |Improvement|
  +----------+         +----------+
       |                      |
       v                      v
     V^pi <---------------- pi(a|s)
       value function  <-->  policy

DP：完整评估 + 完整改进（需要模型）
MC：MC 评估 + 改进（无模型，回合制）
TD：TD 评估 + 改进（无模型，在线）

6. 蒙特卡洛方法¶

蒙特卡洛（Monte Carlo, MC）方法从**完整的回合经验**中学习——不需要模型。

6.1 MC 预测¶

通过对状态 \(s\) 所有访问的回报取平均来估计 \(V^\pi(s)\)：

\[V(s) \leftarrow V(s) + \alpha [G_t - V(s)]\]

首次访问 MC（First-visit MC）：仅使用每个回合中第一次访问 \(s\) 的回报。 每次访问 MC（Every-visit MC）：使用对 \(s\) 的每次访问。

6.2 MC 控制¶

使用 MC 估计 \(Q(s,a)\)，然后贪心地改进策略：

Initialize Q(s,a) arbitrarily, pi(s) <- argmax_a Q(s,a)
Repeat forever:
    Generate episode using pi: S_0, A_0, R_1, ..., S_{T-1}, A_{T-1}, R_T
    G <- 0
    For t = T-1, T-2, ..., 0:
        G <- gamma*G + R_{t+1}
        If (S_t, A_t) not in earlier pairs:
            Q(S_t, A_t) <- average of all returns following (S_t, A_t)
            pi(S_t) <- argmax_a Q(S_t, a)

6.3 离线策略 MC（重要性采样）¶

在遵循策略 \(b\)（行为策略）的同时学习策略 \(\pi\)（目标策略）：

\[\rho_{t:T-1} = \prod_{k=t}^{T-1} \frac{\pi(A_k|S_k)}{b(A_k|S_k)}\]

\[V(s) \leftarrow V(s) + \alpha \left[\rho_{t:T-1} G_t - V(s)\right]\]

7. 时序差分学习（预览）¶

时序差分（Temporal Difference, TD）方法结合了 MC 和 DP 的思想：像 MC 一样从回合中学习，但像 DP 一样进行自举（Bootstrap）。

7.1 TD(0) 预测¶

TD 更新规则：

\[V(s_t) \leftarrow V(s_t) + \alpha \left[ r_{t+1} + \gamma V(s_{t+1}) - V(s_t) \right]\]

项 \(\delta_t = r_{t+1} + \gamma V(s_{t+1}) - V(s_t)\) 称为 TD 误差（TD Error）。

7.2 TD vs. MC vs. DP¶

属性	DP	MC	TD
需要模型？	是 (P, R)	否	否
自举？	是	否	是
每步更新	所有状态	回合结束	每一步
收敛性	精确	渐近	渐近
处理非平稳性	否	是	是

7.3 SARSA 与 Q-Learning（预览）¶

SARSA（在线策略 TD 控制）：

\[Q(s_t, a_t) \leftarrow Q(s_t, a_t) + \alpha \left[ r_{t+1} + \gamma Q(s_{t+1}, a_{t+1}) - Q(s_t, a_t) \right]\]

Q-Learning（离线策略 TD 控制）：

\[Q(s_t, a_t) \leftarrow Q(s_t, a_t) + \alpha \left[ r_{t+1} + \gamma \max_a Q(s_{t+1}, a) - Q(s_t, a_t) \right]\]

详细内容

请参阅时序差分学习页面获取完整实现和比较。

8. RL 算法全景图¶

                    Reinforcement Learning
                           |
            +--------------+--------------+
            |              |              |
     Model-Free       Model-Based      Imitation
            |              |          Learning
    +-------+-------+      |
    |               |    World Models
 Value-Based   Policy-Based   Dyna, MBPO
    |               |
    +-- Q-Learning  +-- REINFORCE
    +-- SARSA       +-- Actor-Critic
    +-- DQN         +-- PPO, TRPO
    +-- Double DQN  +-- SAC, TD3

算法	类型	在线/离线策略	自举	模型
价值迭代	值函数	--	是	是
MC 控制	值函数	在线策略	否	否
Q-Learning	值函数	离线策略	是	否
SARSA	值函数	在线策略	是	否
DQN	值函数	离线策略	是	否
REINFORCE	策略	在线策略	否	否
A2C/A3C	Actor-Critic	在线策略	是	否
PPO	Actor-Critic	在线策略	是	否
SAC	Actor-Critic	离线策略	是	否
DDPG	Actor-Critic	离线策略	是	否

9. 动手项目：使用 Gymnasium 的网格世界¶

从零开始构建一个完整的 RL 项目：定义网格世界环境，用 Q-Learning 求解，并可视化结果。

import numpy as np
import gymnasium as gym
from gymnasium import spaces
import matplotlib.pyplot as plt

class GridWorldEnv(gym.Env):
    """A simple Grid World with obstacles and a goal."""
    metadata = {"render_modes": ["human"]}

    def __init__(self, size=5):
        super().__init__()
        self.size = size
        self.action_space = spaces.Discrete(4)
        self.observation_space = spaces.Discrete(size * size)
        self.actions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
        self.obstacles = [(1, 1), (1, 3), (3, 1), (3, 3)]
        self.goal = (size - 1, size - 1)
        self.start = (0, 0)

    def reset(self, seed=None):
        super().reset(seed=seed)
        self.agent_pos = self.start
        return self._pos_to_state(self.agent_pos), {}

    def step(self, action):
        dr, dc = self.actions[action]
        r, c = self.agent_pos
        nr, nc = r + dr, c + dc
        if 0 <= nr < self.size and 0 <= nc < self.size and (nr, nc) not in self.obstacles:
            self.agent_pos = (nr, nc)
        reward = -1.0
        terminated = self.agent_pos == self.goal
        if terminated:
            reward = 10.0
        return self._pos_to_state(self.agent_pos), reward, terminated, False, {}

    def _pos_to_state(self, pos):
        return pos[0] * self.size + pos[1]


def q_learning(env, episodes=500, alpha=0.1, gamma=0.99, epsilon=0.1):
    """Tabular Q-Learning for the Grid World."""
    n_states = env.observation_space.n
    n_actions = env.action_space.n
    Q = np.zeros((n_states, n_actions))
    rewards_per_episode = []

    for ep in range(episodes):
        state, _ = env.reset()
        total_reward = 0
        done = False
        while not done:
            if np.random.random() < epsilon:
                action = env.action_space.sample()
            else:
                action = np.argmax(Q[state])
            next_state, reward, terminated, truncated, _ = env.step(action)
            done = terminated or truncated
            Q[state, action] += alpha * (
                reward + gamma * np.max(Q[next_state]) * (1 - terminated) - Q[state, action]
            )
            state = next_state
            total_reward += reward
        rewards_per_episode.append(total_reward)
    return Q, rewards_per_episode


def visualize_policy(Q, env):
    """Visualize the learned policy and value function."""
    arrows = ['^', 'v', '<', '>']
    V = np.max(Q, axis=1).reshape(env.size, env.size)
    policy = np.argmax(Q, axis=1).reshape(env.size, env.size)
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
    V_display = V.copy()
    for obs in env.obstacles:
        V_display[obs] = np.nan
    im = ax1.imshow(V_display, cmap='YlOrRd', interpolation='nearest')
    ax1.set_title('Value Function V(s)')
    plt.colorbar(im, ax=ax1)
    ax2.imshow(np.ones((env.size, env.size)), cmap='Greys', alpha=0.1)
    for r in range(env.size):
        for c in range(env.size):
            if (r, c) in env.obstacles:
                ax2.add_patch(plt.Rectangle((c-0.4, r-0.4), 0.8, 0.8, color='gray'))
            elif (r, c) == env.goal:
                ax2.text(c, r, 'G', ha='center', va='center', fontsize=16, fontweight='bold')
            else:
                ax2.text(c, r, arrows[policy[r, c]], ha='center', va='center', fontsize=18)
    ax2.set_title('Optimal Policy')
    plt.tight_layout(); plt.savefig('grid_world_solution.png', dpi=150); plt.show()


# Run the complete project
env = GridWorldEnv(size=5)
Q, rewards = q_learning(env, episodes=500)
print(f"Average reward (last 100 episodes): {np.mean(rewards[-100:]):.2f}")
visualize_policy(Q, env)

10. RL 在机器人中的应用：为什么基础知识很重要¶

理解 RL 基础知识对机器人至关重要，原因如下：

奖励设计（Reward Design）：贝尔曼方程告诉我们奖励塑形如何影响最优策略（基于势函数的塑形保持最优性）。
样本效率（Sample Efficiency）：理解自举（TD）与完整回报（MC）有助于为昂贵的真实世界交互选择合适的算法。
安全关键系统中的探索：多臂老虎机理论指导安全的探索策略。
仿真到现实迁移（Sim-to-Real Transfer）：DP 和基于模型的方法与系统辨识和模型预测控制相连接。

机器人特定挑战¶

挑战	RL 概念	解决方案
连续状态/动作	函数逼近（Function Approximation）	深度 RL（DQN, PPO, SAC）
稀疏奖励	信用分配（Credit Assignment）	奖励塑形（Reward Shaping）, HER
安全约束	约束 MDP（Constrained MDP）	安全 RL, 拉格朗日方法
样本低效	基于模型的 RL	世界模型（World Models）, Dyna
仿真到现实差距	域随机化（Domain Randomization）	系统辨识（System Identification）

练习¶

练习 1：老虎机实现¶

实现 10 臂老虎机测试平台，比较 \(\epsilon\)-贪心（\(\epsilon\)=0, 0.01, 0.1）和 UCB（\(c\)=2）。绘制 1000 步的平均奖励曲线。

练习 2：策略评估¶

给定一个 4x4 网格世界和随机策略，手动实现迭代策略评估。验证结果与解析解一致。

练习 3：价值迭代¶

将网格世界扩展到 10x10 并添加随机障碍物。实现价值迭代并找到最优策略。

练习 4：MC vs. TD¶

为随机游走环境实现 MC 预测和 TD(0) 预测。比较它们的学习曲线。

练习 5：使用 Gymnasium 的 Q-Learning¶

使用 Gymnasium 的 FrozenLake-v1 环境训练 Q-Learning 智能体。尝试不同的 \(\epsilon\)、\(\alpha\) 和 \(\gamma\) 值。

练习 6：贝尔曼方程证明¶

证明最优值函数 \(V^*\) 满足贝尔曼最优方程：

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

提示：使用策略改进定理以及 \(V^* = \max_\pi V^\pi\) 这一事实。

参考资料¶

Sutton & Barto (2018), Reinforcement Learning: An Introduction -- 权威 RL 教材，可在线免费获取
David Silver 的 UCL RL 课程 -- 涵盖 MDP、DP、MC、TD、策略梯度的优秀讲座系列
OpenAI Spinning Up in Deep RL -- 深度 RL 算法的实践入门，附 PyTorch 实现
Gymnasium 文档 -- 标准 RL 环境 API（OpenAI Gym 的继任者）
DeepMind x UCL: Introduction to Reinforcement Learning -- 视频讲座和幻灯片
Hugging Face Deep RL Course -- 动手实践课程
Szepesvari, Algorithms for Reinforcement Learning -- 严谨的理论处理
Bertsekas, Reinforcement Learning and Optimal Control -- 与最优控制理论的联系