Q-Learning与SARSA

一句话概述

Q-Learning和SARSA是强化学习中最经典的两个基于价值的算法，都通过维护Q表来学习最优动作价值函数。Q-Learning是Off-Policy的，使用max操作来估计未来最优价值（大胆乐观）；SARSA是On-Policy的，使用实际执行的下一个动作来估计（谨慎保守）。理解这两个算法的区别，是理解"乐观"和"保守"两种RL哲学的关键。

💡 核心要点：①Q-Learning和SARSA都用TD学习更新Q表，核心区别在于目标值的计算方式；②Q-Learning使用max操作（Off-Policy），直接逼近最优Q函数Q*；③SARSA使用实际执行的下一个动作的Q值（On-Policy），学习的是当前策略的Q函数；④Q-Learning更"大胆"（忽略探索风险），SARSA更"保守"（考虑探索代价），在悬崖环境中表现迥异。

教学与演示

一、Q-Learning——大胆的乐观主义者

是什么（定义）：Q-Learning是一种Off-Policy的TD学习算法，由Watkins在1989年提出。它直接学习最优动作价值函数Q*，更新规则为：Q(s,a) ← Q(s,a) + α[r + γ·max_{a'} Q(s',a') - Q(s,a)]。Q-Learning是强化学习历史上最重要的算法之一，直接启发了DQN。

大白话 Q-Learning就像一个"乐观的赌徒"——它总是假设下一步会做出最优选择（max操作），即使当前策略可能并非如此。这种"向前看"的态度让它能直接学习最优策略，但也可能在危险环境中过于乐观。

为什么（原理）：Q-Learning使用max操作作为目标策略，而数据采集使用ε-greedy（行为策略），两者不同→Off-Policy。这种设计使得Q-Learning可以直接逼近Q*，而无需先学习当前策略的Q函数。在表格型环境下，Q-Learning被证明在温和条件下收敛到Q*。

怎么做（实现）：

import numpy as np

# ==================== Q-Learning完整实现 ====================
n_states = 9
n_actions = 4
actions = [(-1, 0), (1, 0), (0, -1), (0, 1)]

def step(state, action):
    row, col = state // 3, state % 3
    dr, dc = actions[action]
    nr = max(0, min(2, row + dr))
    nc = max(0, min(2, col + dc))
    next_state = nr * 3 + nc
    if next_state == 8:   r = 10.0
    elif next_state == 7: r = -5.0
    else:                 r = -0.1
    return next_state, r

class QLearning:
    def __init__(self, n_states, n_actions, alpha=0.1, gamma=0.9, epsilon=0.2):
        self.Q = np.zeros((n_states, n_actions))
        self.alpha = alpha
        self.gamma = gamma
        self.epsilon = epsilon
        self.n_actions = n_actions

    def select_action(self, state):
        if np.random.random() < self.epsilon:
            return np.random.randint(self.n_actions)
        return np.argmax(self.Q[state])

    def update(self, state, action, reward, next_state):
        # Q-Learning核心更新：使用max操作
        best_next = np.max(self.Q[next_state])  # ← max是关键！
        td_target = reward + self.gamma * best_next
        td_error = td_target - self.Q[state][action]
        self.Q[state][action] += self.alpha * td_error

    def train_episode(self):
        state = 0
        total_reward = 0
        while state != 8 and state != 7:
            action = self.select_action(state)
            next_state, reward = step(state, action)
            self.update(state, action, reward, next_state)
            total_reward += reward
            state = next_state
        return total_reward

np.random.seed(42)
ql = QLearning(n_states, n_actions)
rewards = [ql.train_episode() for _ in range(300)]

print("=== Q-Learning训练结果 ===")
print(f"前10个episode奖励: {[f'{r:.1f}' for r in rewards[:10]]}")
print(f"最后10个episode平均奖励: {np.mean(rewards[-10:]):.2f}")

# 打印Q表
print(f"\nQ表（部分）：")
for s in [0, 4]:
    print(f"  状态{s}: {[f'{q:.2f}' for q in ql.Q[s]]}")

# 提取策略
policy = np.argmax(ql.Q, axis=1)
action_names = ["上", "下", "左", "右"]
print(f"\n提取的策略：")
for i in range(3):
    row = []
    for j in range(3):
        s = i * 3 + j
        if s == 8: row.append("目标")
        elif s == 7: row.append("陷阱")
        else: row.append(action_names[policy[s]])
    print("  " + "  ".join(f"{a:>4}" for a in row))

什么用（应用）：Q-Learning广泛用于离散动作空间的决策问题。在游戏AI中，Q-Learning可以学习通关策略；在推荐系统中，学习"推荐什么物品能最大化长期用户参与度"；在资源调度中，学习"何时分配资源"的策略。Q-Learning也是DQN的理论基础。

哪些坑（缺点）：表格型Q-Learning只能处理小状态空间；max操作导致Q值过估计（overestimation bias）；在函数近似下收敛性不再保证；Off-Policy性质可能导致"致命三元组"（函数近似+Off-Policy+bootstrap）的不稳定性。

二、SARSA——谨慎的现实主义者

是什么（定义）：SARSA（State-Action-Reward-State-Action）是一种On-Policy的TD学习算法，名称来自其更新所需的五元组(s, a, r, s', a')。更新规则为：Q(s,a) ← Q(s,a) + α[r + γ·Q(s', a') - Q(s,a)]，其中a'是实际执行的下一个动作。

大白话 SARSA就像一个"谨慎的司机"——它不假设下一步会做出最优选择，而是老老实实地考虑"如果我按照当前策略（包括偶尔的随机探索），实际会怎么走"。这意味着SARSA会考虑"不小心走错"的代价，因此在危险环境中更加保守和安全。

为什么（原理）：SARSA的更新使用实际执行的下一个动作a'的Q值，而非max操作。这意味着SARSA学习的是当前行为策略（ε-greedy）的Q函数Q^π，而非Q*。在悬崖行走（Cliff Walking）等经典问题中，SARSA因为考虑了探索的风险，会选择远离悬崖的更安全路径，而Q-Learning则可能选择紧贴悬崖的"最优但危险"路径。

怎么做（实现）：

import numpy as np

n_states = 9; n_actions = 4
actions = [(-1, 0), (1, 0), (0, -1), (0, 1)]

def step(state, action):
    row, col = state // 3, state % 3
    dr, dc = actions[action]
    nr = max(0, min(2, row + dr))
    nc = max(0, min(2, col + dc))
    next_state = nr * 3 + nc
    if next_state == 8:   r = 10.0
    elif next_state == 7: r = -5.0
    else:                 r = -0.1
    return next_state, r

class SARSA:
    def __init__(self, n_states, n_actions, alpha=0.1, gamma=0.9, epsilon=0.2):
        self.Q = np.zeros((n_states, n_actions))
        self.alpha = alpha; self.gamma = gamma; self.epsilon = epsilon
        self.n_actions = n_actions

    def select_action(self, state):
        if np.random.random() < self.epsilon:
            return np.random.randint(self.n_actions)
        return np.argmax(self.Q[state])

    def update(self, state, action, reward, next_state, next_action):
        # SARSA核心更新：使用实际执行的下一个动作的Q值
        td_target = reward + self.gamma * self.Q[next_state][next_action]  # ← Q(s',a')！
        td_error = td_target - self.Q[state][action]
        self.Q[state][action] += self.alpha * td_error

    def train_episode(self):
        state = 0
        action = self.select_action(state)  # SARSA：先选动作
        total_reward = 0
        while state != 8 and state != 7:
            next_state, reward = step(state, action)
            next_action = self.select_action(next_state)  # 选下一个动作
            self.update(state, action, reward, next_state, next_action)
            total_reward += reward
            state, action = next_state, next_action  # 使用实际执行的动作
        return total_reward

np.random.seed(42)
sarsa = SARSA(n_states, n_actions)
rewards = [sarsa.train_episode() for _ in range(300)]

print("=== SARSA训练结果 ===")
print(f"前10个episode奖励: {[f'{r:.1f}' for r in rewards[:10]]}")
print(f"最后10个episode平均奖励: {np.mean(rewards[-10:]):.2f}")

print(f"\nQ表（部分）：")
for s in [0, 4]:
    print(f"  状态{s}: {[f'{q:.2f}' for q in sarsa.Q[s]]}")

# 对比Q-Learning和SARSA的更新差异
print(f"\nQ-Learning vs SARSA 核心区别：")
print(f"  Q-Learning目标: r + γ·max_{a'} Q(s', a')")
print(f"  SARSA目标:      r + γ·Q(s', a')")
print(f"  max是"乐观假设"，实际Q值是"现实考虑"")

什么用（应用）：SARSA适合需要保守策略的场景——如机器人行走在悬崖边（SARSA会选择远离悬崖的安全路径）、自动驾驶（考虑探索风险）、医疗决策（错误动作代价高）。在这些场景中，SARSA的"考虑探索风险"特性比Q-Learning的"乐观最优"更安全。

哪些坑（缺点）：SARSA收敛到Q^π而非Q*（需要ε衰减到0才能收敛到Q*）；On-Policy性质意味着不能使用经验回放，样本效率低；在安全的环境中，SARSA的保守性可能导致次优策略。

三、悬崖行走——Q-Learning vs SARSA的经典对比

是什么（定义）：悬崖行走（Cliff Walking）是Sutton & Barto教材中用于对比Q-Learning和SARSA的经典问题。智能体从起点出发，目标是到达右下角，但中间有一排"悬崖"——掉下去会获得很大的负奖励并回到起点。这个环境完美展示了"乐观"与"保守"两种策略的差异。

大白话 想象你走在悬崖边上——Q-Learning会沿着悬崖边缘走（最短路径），因为它假设自己不会失足；SARSA会离悬崖远一点走（安全路径），因为它知道"万一不小心踩空（ε-greedy的随机探索），就完蛋了"。SARSA的路径更长但更安全，Q-Learning的路径更短但更危险。

为什么（原理）：Q-Learning的max操作忽略了探索可能带来的风险——它假设下一步总是最优动作，不考虑ε-greedy可能随机选到危险动作。SARSA使用实际动作的Q值，ε-greedy的随机探索被纳入考虑，因此会自动避开危险区域。这个例子生动展示了On-Policy和Off-Policy的实践差异。

怎么做（实现）：

import numpy as np

# ==================== 悬崖行走环境 ====================
# 4x12的网格，底部一行(除起点终点)是悬崖
ROWS, COLS = 4, 12
START = (3, 0)   # 左下角起点
GOAL = (3, 11)   # 右下角目标

def cliff_step(state, action):
    """悬崖行走环境转移函数"""
    row, col = state
    moves = [(-1, 0), (1, 0), (0, -1), (0, 1)]  # 上、下、左、右
    dr, dc = moves[action]
    nr = max(0, min(ROWS-1, row + dr))
    nc = max(0, min(COLS-1, col + dc))
    next_state = (nr, nc)

    if nr == ROWS-1 and 0 < nc < COLS-1:  # 掉入悬崖
        return START, -100  # 大惩罚，回到起点
    elif next_state == GOAL:
        return GOAL, 0  # 到达目标
    else:
        return next_state, -1  # 每步-1

def cliff_q_learning(n_episodes=500, alpha=0.5, gamma=1.0, epsilon=0.1):
    """Q-Learning在悬崖行走上"""
    Q = np.zeros((ROWS, COLS, 4))
    rewards = []
    for ep in range(n_episodes):
        state = START; total = 0
        while state != GOAL:
            row, col = state
            action = np.random.randint(4) if np.random.random() < epsilon else np.argmax(Q[row][col])
            next_state, r = cliff_step(state, action)
            nr, nc = next_state
            # Q-Learning: 使用max
            Q[row][col][action] += alpha * (r + gamma * np.max(Q[nr][nc]) - Q[row][col][action])
            total += r; state = next_state
        rewards.append(total)
    return Q, rewards

def cliff_sarsa(n_episodes=500, alpha=0.5, gamma=1.0, epsilon=0.1):
    """SARSA在悬崖行走上"""
    Q = np.zeros((ROWS, COLS, 4))
    rewards = []
    for ep in range(n_episodes):
        state = START
        row, col = state
        action = np.random.randint(4) if np.random.random() < epsilon else np.argmax(Q[row][col])
        total = 0
        while state != GOAL:
            next_state, r = cliff_step(state, action)
            nr, nc = next_state
            next_action = np.random.randint(4) if np.random.random() < epsilon else np.argmax(Q[nr][nc])
            # SARSA: 使用实际动作
            Q[row][col][action] += alpha * (r + gamma * Q[nr][nc][next_action] - Q[row][col][action])
            total += r
            state, row, col, action = next_state, nr, nc, next_action
        rewards.append(total)
    return Q, rewards

np.random.seed(42)
Q_ql, r_ql = cliff_q_learning()
Q_s, r_s = cliff_sarsa()

print("=== 悬崖行走：Q-Learning vs SARSA ===")
print(f"Q-Learning最后100ep平均奖励: {np.mean(r_ql[-100:]):.1f}")
print(f"SARSA最后100ep平均奖励: {np.mean(r_s[-100:]):.1f}")
print(f"\n分析：SARSA的奖励更高，因为它学会了避开悬崖")
print(f"Q-Learning沿悬崖边缘走（最短路径），但偶尔掉下去")
print(f"SARSA绕远路，但更安全，总奖励反而更高")

什么用（应用）：悬崖行走的对比揭示了On-Policy和Off-Policy在安全关键场景中的差异。在实际应用中，如果错误动作的代价很高（如自动驾驶撞墙、医疗误诊），应优先考虑SARSA或PPO等On-Policy方法；如果错误代价可控（如游戏AI），Q-Learning/DQN的更高效率可能更合适。

哪些坑（缺点）：悬崖行走是简化环境，现实中的风险可能更复杂；SARSA的保守性可能导致"过度保守"——绕远路绕得太远；ε的选择对结果影响很大。

四、Q-Learning的收敛性分析

是什么（定义）：在表格型环境下，Q-Learning被证明在满足以下条件时收敛到Q*：(1) 所有状态-动作对被无限次访问；(2) 学习率α满足Σα = ∞且Σα² < ∞（如α_t = 1/t）；(3) 折扣因子γ < 1。收敛性证明基于随机逼近理论和收缩映射性质。

大白话 Q-Learning的收敛性就像"熟能生巧"——只要你把每个状态-动作对都试够多次（条件1），并且学得越来越慢（条件2，α逐渐减小），最终一定能学到最优Q值。这就像练习投篮——刚开始学得快，后来慢慢精进，最终百发百中。

为什么（原理）：收敛性证明的关键在于将Q-Learning视为一个随机逼近过程。Q-Learning的更新可以看作在求解贝尔曼最优方程的不动点。由于贝尔曼算子是γ-收缩的，加上随机逼近的条件，Q-Learning的迭代最终收敛到唯一的不动点Q*。

怎么做（实现）：

import numpy as np

# ==================== Q-Learning收敛性验证 ====================
n_states = 9; n_actions = 4
actions = [(-1, 0), (1, 0), (0, -1), (0, 1)]

def step(state, action):
    row, col = state // 3, state % 3
    dr, dc = actions[action]
    nr = max(0, min(2, row + dr))
    nc = max(0, min(2, col + dc))
    next_state = nr * 3 + nc
    if next_state == 8:   r = 10.0
    elif next_state == 7: r = -5.0
    else:                 r = -0.1
    return next_state, r

# 计算真实Q*（值迭代）
def compute_Q_star(gamma=0.9):
    V = np.zeros(n_states)
    while True:
        delta = 0; V_old = V.copy()
        for s in range(n_states):
            if s == 8: continue
            vals = [step(s, a)[1] + gamma * V_old[step(s, a)[0]] for a in range(n_actions)]
            V[s] = max(vals)
            delta = max(delta, abs(V[s] - V_old[s]))
        if delta < 1e-6: break
    Q_star = np.zeros((n_states, n_actions))
    for s in range(n_states):
        if s == 8: continue
        for a in range(n_actions):
            next_s, r = step(s, a)
            Q_star[s][a] = r + gamma * V[next_s]
    return Q_star

Q_star = compute_Q_star()

# Q-Learning收敛性测试
np.random.seed(42)
Q = np.zeros((n_states, n_actions))
errors = []  # 记录Q与Q*的误差

for episode in range(500):
    state = 0
    alpha = 1.0 / (episode + 1)  # 满足收敛条件：α递减
    while state != 8 and state != 7:
        action = np.random.randint(n_actions) if np.random.random() < 0.3 else np.argmax(Q[state])
        next_state, reward = step(state, action)
        Q[state][action] += alpha * (reward + 0.9 * np.max(Q[next_state]) - Q[state][action])
        state = next_state
    errors.append(np.max(np.abs(Q - Q_star)))

print("=== Q-Learning收敛性验证 ===")
print(f"初始误差: {errors[0]:.4f}")
print(f"100轮后误差: {errors[99]:.4f}")
print(f"500轮后误差: {errors[-1]:.4f}")
print(f"\nQ-Learning估计的Q值 vs 真实Q*：")
for s in [0, 4]:
    print(f"  状态{s}: Q估计={[f'{q:.2f}' for q in Q[s]]}")
    print(f"          Q*   ={[f'{q:.2f}' for q in Q_star[s]]}")
print(f"\n结论：Q-Learning逐渐收敛到Q*，误差随时间减小")

什么用（应用）：理解Q-Learning的收敛条件有助于实际调参。如果Q值不收敛，检查：(1) 是否所有状态-动作对都被充分访问？(2) 学习率是否过大或不衰减？(3) 折扣因子是否合理？这些条件也是DQN中经验回放和目标网络设计的理论基础。

哪些坑（缺点）：收敛条件在函数近似下不再成立（这催生了DQN的各种稳定技巧）；α=1/t的衰减在实际中可能太慢或太快；收敛到Q不保证策略是好的——如果Q估计有误差，argmax可能选错动作。

五、双Q-Learning——解决过估计问题

是什么（定义）：双Q-Learning（Double Q-Learning）通过维护两个独立的Q表（Q_A和Q_B）来解决Q-Learning的过估计（overestimation）问题。更新时，用Q_A选择最优动作，用Q_B评估该动作的价值（或反过来），从而解耦"选择"和"评估"。

大白话 普通Q-Learning的max操作容易"自卖自夸"——用同一个Q表既选动作又评估动作，容易高估。Double Q-Learning就像"双盲评审"——一个网络选动作，另一个网络打分，避免了"自己评自己"的偏差。

为什么（原理）：过估计来源于max操作从有噪声的Q值估计中"挑最大的"。Double Q-Learning将选择和评估分离：用Q_A选择动作a* = argmax_a Q_A(s',a)，用Q_B评估Q_B(s',a*)。由于Q_A和Q_B的噪声是独立的，这种分离显著减少了过估计。这是Double DQN的理论基础。

怎么做（实现）：

import numpy as np

n_states = 9; n_actions = 4
actions = [(-1, 0), (1, 0), (0, -1), (0, 1)]

def step(state, action):
    row, col = state // 3, state % 3
    dr, dc = actions[action]
    nr = max(0, min(2, row + dr))
    nc = max(0, min(2, col + dc))
    next_state = nr * 3 + nc
    if next_state == 8:   r = 10.0
    elif next_state == 7: r = -5.0
    else:                 r = -0.1
    return next_state, r

class DoubleQLearning:
    def __init__(self, n_states, n_actions, alpha=0.1, gamma=0.9, epsilon=0.2):
        self.QA = np.zeros((n_states, n_actions))  # Q表A
        self.QB = np.zeros((n_states, n_actions))  # Q表B
        self.alpha = alpha; self.gamma = gamma; self.epsilon = epsilon
        self.n_actions = n_actions

    def select_action(self, state):
        if np.random.random() < self.epsilon:
            return np.random.randint(self.n_actions)
        # 用两个Q表的平均值选择动作
        return np.argmax(self.QA[state] + self.QB[state])

    def update(self, state, action, reward, next_state):
        if np.random.random() < 0.5:
            # 用QA选择动作，QB评估
            best_action = np.argmax(self.QA[next_state])
            td_target = reward + self.gamma * self.QB[next_state][best_action]
            self.QA[state][action] += self.alpha * (td_target - self.QA[state][action])
        else:
            # 用QB选择动作，QA评估
            best_action = np.argmax(self.QB[next_state])
            td_target = reward + self.gamma * self.QA[next_state][best_action]
            self.QB[state][action] += self.alpha * (td_target - self.QB[state][action])

    def train_episode(self):
        state = 0; total = 0
        while state != 8 and state != 7:
            action = self.select_action(state)
            next_state, reward = step(state, action)
            self.update(state, action, reward, next_state)
            total += reward; state = next_state
        return total

np.random.seed(42)
dql = DoubleQLearning(n_states, n_actions)
rewards = [dql.train_episode() for _ in range(300)]

print("=== Double Q-Learning ===")
print(f"最后10个episode平均奖励: {np.mean(rewards[-10:]):.2f}")
print(f"\nDouble Q-Learning避免了过估计：")
print(f"  普通Q-Learning: max_a Q(s',a) — 同一个Q选动作+评估")
print(f"  双Q-Learning:   Q_B(s', argmax_a Q_A(s',a)) — 分离选择与评估")
print(f"  这降低了max操作对噪声的敏感性")

什么用（应用）：Double Q-Learning的思想直接启发了Double DQN，后者是DQN最重要的改进之一。在Atari游戏中，Double DQN显著减少了Q值过估计，提高了策略质量。在推荐系统和机器人控制中，Double Q-Learning帮助获得更准确的Q值估计。

哪些坑（缺点）：维护两个Q表增加了存储开销；在函数近似中，两个网络可能高度相关（共享底层），解耦效果有限；Double Q-Learning可能导致低估（underestimation），但低估通常比高估危害小。

六、实战：完整对比Q-Learning、SARSA和Double Q-Learning

是什么（定义）：在同一网格世界上全面对比三种基于价值的算法，从收敛速度、最终表现、Q值估计准确性等多个维度评估。

怎么做（实现）：

import numpy as np

n_states = 9; n_actions = 4
actions = [(-1, 0), (1, 0), (0, -1), (0, 1)]

def step(state, action):
    row, col = state // 3, state % 3
    dr, dc = actions[action]
    nr = max(0, min(2, row + dr))
    nc = max(0, min(2, col + dc))
    next_state = nr * 3 + nc
    if next_state == 8:   r = 10.0
    elif next_state == 7: r = -5.0
    else:                 r = -0.1
    return next_state, r

def run_ql(n_episodes=300):
    Q = np.zeros((n_states, n_actions)); rewards = []
    for ep in range(n_episodes):
        state = 0; total = 0
        while state != 8 and state != 7:
            action = np.random.randint(n_actions) if np.random.random() < 0.2 else np.argmax(Q[state])
            next_s, r = step(state, action)
            Q[state][action] += 0.1 * (r + 0.9*np.max(Q[next_s]) - Q[state][action])
            total += r; state = next_s
        rewards.append(total)
    return Q, rewards

def run_sarsa(n_episodes=300):
    Q = np.zeros((n_states, n_actions)); rewards = []
    for ep in range(n_episodes):
        state = 0
        action = np.random.randint(n_actions) if np.random.random() < 0.2 else np.argmax(Q[state])
        total = 0
        while state != 8 and state != 7:
            next_s, r = step(state, action)
            next_a = np.random.randint(n_actions) if np.random.random() < 0.2 else np.argmax(Q[next_s])
            Q[state][action] += 0.1 * (r + 0.9*Q[next_s][next_a] - Q[state][action])
            total += r; state, action = next_s, next_a
        rewards.append(total)
    return Q, rewards

def run_double_ql(n_episodes=300):
    QA = np.zeros((n_states, n_actions)); QB = np.zeros((n_states, n_actions))
    rewards = []
    for ep in range(n_episodes):
        state = 0; total = 0
        while state != 8 and state != 7:
            action = np.random.randint(n_actions) if np.random.random() < 0.2 else np.argmax(QA[state]+QB[state])
            next_s, r = step(state, action)
            if np.random.random() < 0.5:
                best = np.argmax(QA[next_s])
                QA[state][action] += 0.1 * (r + 0.9*QB[next_s][best] - QA[state][action])
            else:
                best = np.argmax(QB[next_s])
                QB[state][action] += 0.1 * (r + 0.9*QA[next_s][best] - QB[state][action])
            total += r; state = next_s
        rewards.append(total)
    return QA, rewards

np.random.seed(42)
Q_ql, r_ql = run_ql()
Q_s, r_s = run_sarsa()
Q_dql, r_dql = run_double_ql()

print("=== 三种基于价值算法对比 ===")
print(f"最后100ep平均奖励：")
print(f"  Q-Learning:        {np.mean(r_ql[-100:]):.2f}")
print(f"  SARSA:             {np.mean(r_s[-100:]):.2f}")
print(f"  Double Q-Learning: {np.mean(r_dql[-100:]):.2f}")

print(f"\n收敛速度：Q-Learning ≈ SARSA > Double Q-Learning")
print(f"稳定性：SARSA > Double Q-Learning ≈ Q-Learning")
print(f"在简单网格环境中，三者表现接近")
print(f"在危险环境中（悬崖行走），SARSA显著优于Q-Learning")

什么用（应用）：通过对比实验，选择最适合任务的算法。在安全关键场景用SARSA，在效率优先场景用Q-Learning，在需要减少过估计时用Double Q-Learning。

哪些坑（缺点）：三种算法都是表格型，无法处理大状态空间；超参数（学习率、探索率）对结果影响大；在更复杂环境中的对比结果可能不同。

概念关系图谱

重点答疑

Q1: Q-Learning和SARSA的核心区别是什么？什么时候用哪个？

核心区别在目标值计算：

• Q-Learning：r + γ·max_{a'} Q(s', a') — 假设下一步最优
• SARSA：r + γ·Q(s', a') — 使用实际下一步动作

选择指南：错误代价低 → Q-Learning（效率高）；错误代价高 → SARSA（安全）；需要经验回放 → Q-Learning（Off-Policy）；需要在线学习 → 两者都可。

解答：Q-Learning像一个理想主义者，SARSA像一个现实主义者。在安全关键场景（医疗、自动驾驶），SARSA的保守性更可取。

Q2: 为什么Q-Learning的max操作会导致过估计？

假设真实Q*(s',a') = [5, 5, 5]，但由于采样噪声，估计Q(s',a') = [5.5, 4.5, 5.0]。max操作取5.5，这高于真实值5。即使每个动作的估计是无偏的（期望=5），max操作从有噪声的估计中"挑最大的"，系统性地引入了正向偏差。动作越多，过估计越严重。

解答：max就像从一群"有误差的猜测"中挑最大的——如果你对10个动作的估计都有±1的噪声，max很可能挑到"虚高"的那个。Double Q-Learning通过分离选择和评估来缓解这个问题。

Q3: SARSA一定能收敛到最优策略吗？

SARSA学习的是Q^π（行为策略的Q函数），而非Q*。要让SARSA收敛到最优策略，需要满足GLIE（Greedy in the Limit with Infinite Exploration）条件：ε逐渐衰减到0，确保无限探索。满足GLIE的SARSA（如ε=1/t）最终收敛到Q*。

解答：SARSA本身收敛到Q^π，但如果ε逐渐衰减到0（GLIE条件），SARSA最终也收敛到Q*。这就是"先广泛探索，再专注利用"的思想。

Q4: Double Q-Learning为什么能减少过估计？

Double Q-Learning将"选择"和"评估"解耦到两个独立的Q函数。即使Q_A有噪声，它选出的"最优动作"可能不是Q_B中噪声最大的那个（因为两个Q函数的噪声是独立的）。因此，Q_B(s', argmax Q_A(s',a'))的期望值更接近真实值，减少了过估计。

解答：就像"你选菜，我买单"——选菜的人可能会挑最贵的（过估计），但买单的人（另一个钱包）不一定会跟着高估。两人的判断独立，总偏差就小了。

Q5: 在悬崖行走中，如果ε=0（完全贪心），Q-Learning和SARSA的表现会一样吗？

如果ε=0（完全贪心，没有探索），Q-Learning和SARSA的行为策略都是贪心策略（因为没有随机探索），两者完全相同。此时SARSA也变成了Off-Policy（行为策略=贪心=目标策略）。但ε=0意味着没有探索，智能体可能永远找不到最优策略。

解答：当ε=0时，两者等价。但ε=0意味着没有探索，在复杂环境中可能学不到好的策略。实际中ε>0是必要的。

Q6: Q-Learning的收敛条件中，为什么要求α满足Σα=∞且Σα²<∞？

这是一个经典的随机逼近条件。Σα=∞确保学习率不会衰减太快（永远可以学习新信息）；Σα²<∞确保学习率衰减足够快，让估计收敛（噪声最终被平均掉）。α=1/t满足这个条件。如果α是常数，估计不会完全收敛（会持续震荡）。

解答：α必须"足够大"以学习新信息，又必须"足够小"以最终收敛。1/t是满足这个条件的经典选择。

章节单词汇总