强化学习基础

1. 基本概念

• Agent（智能体）：在环境中执行动作并学习如何最大化累积奖励的实体。
• Environment（环境）：智能体与之交互的外部系统，定义了状态空间、动作空间和奖励机制。
• Observation（观察）：智能体从环境中获取的当前状态信息。
• Action（动作）：智能体在某个状态下可以执行的操作，影响环境的状态。
• Reward（奖励）：智能体执行某个动作后环境反馈的即时信号，用于指导智能体的学习。

强化学习就是智能体和环境之间持续交互，通过与环境交互并观察环境的状态，学习如何采取进一步的行动，以最大化累积奖励，在不断试错的过程中学习如何在不同状态下做出最佳决策的过程。

2. 马尔可夫过程

2.1 马尔可夫性质

2.1.1 本质

• 一个随机过程在给定现在状态及所有过去状态情况下，其未来状态的条件概率分布仅依赖于当前状态，与历史状态无关。

2.1.2 数学定义

• 假设随机变量 $X_0, X_1, ..., X_{T-1}, X_T$ 构成一个随机过程。这些随机变量的所有可能取值的集合被称为状态空间。如果

 则称其满足马尔可夫性质。

• 其中：

  • $X_{0:t}$ 表示变量集合 $X_0, X_1, ..., X_{t-1}, X_t$
  • $x_{0:t}$ 表示变量集合 $x_0, x_1, ..., x_{t-1}, x_t$

• 马尔可夫性质也可以描述为：给定当前状态时，将来的状态与过去状态条件独立。如果某过程满足马尔可夫性质，未来的转移与过去无关，只取决于现在。

2.1.3 直观理解

• 一个失忆的人：
  • 只记得：我现在在哪里
  • 不记得：我是怎么到这里来的
  • 决策下一步行动时，只基于当前位置

假设机器人有三种状态：静止(S)、移动(M)、充电(C)

传统模型（有记忆性）：

# 下一状态可能依赖于整个历史：
# P(下一状态 | 历史 = [C, M, M, S, M]) = ?

马尔科夫模型（无记忆性）：

# 下一状态只依赖于当前状态：
# P(下一状态 | 当前状态 = M) = ?

2.2 马尔科夫链

2.2.1 一阶马尔科夫链 （简单 强大）

基本思路

from enum import Enum
from dataclasses import dataclass
import numpy as np

class RobotState(Enum):
    """机器人状态空间"""
    IDLE = "空闲"      # 静止等待
    MOVING = "移动"    # 正在移动
    CHARGING = "充电"  # 正在充电

@dataclass
class MarkovChain:
    """一阶马尔科夫链实现"""

    # 状态转移矩阵
    # P[next_state | current_state]
    transition_matrix = {
        RobotState.IDLE: {
            RobotState.IDLE: 0.5,     # 保持空闲
            RobotState.MOVING: 0.4,   # 开始移动
            RobotState.CHARGING: 0.1  # 开始充电
        },
        RobotState.MOVING: {
            RobotState.IDLE: 0.3,     # 停止移动
            RobotState.MOVING: 0.5,   # 继续移动
            RobotState.CHARGING: 0.2  # 开始充电
        },
        RobotState.CHARGING: {
            RobotState.IDLE: 0.8,     # 充满电，空闲
            RobotState.MOVING: 0.1,   # 充满电，开始移动
            RobotState.CHARGING: 0.1  # 继续充电
        }
    }

    def next_state(self, current: RobotState) -> RobotState:
        """基于当前状态生成下一个状态"""
        import random

        # 获取当前状态的所有可能转移
        transitions = self.transition_matrix[current]

        # 随机选择（按概率权重）
        states = list(transitions.keys())
        weights = list(transitions.values())

        return random.choices(states, weights=weights)[0]

优点

• 计算简单
  • 只需维护当前状态的转移概率，不存储历史状态
• 数据需求少
  • 估计的参数数量少
• 完整理论体系支持

状态转移矩阵

主要是将转移考虑表示为矩阵的形式，便于运算

import numpy as np

# 状态顺序：[空闲, 移动, 充电]
# 行：当前状态，列：下一状态
P = np.array([
    [0.5, 0.4, 0.1],  # 空闲 → [空闲, 移动, 充电]
    [0.3, 0.5, 0.2],  # 移动 → [空闲, 移动, 充电]
    [0.8, 0.1, 0.1]   # 充电 → [空闲, 移动, 充电]
])

# 关键性质：每行和为1（概率归一化）
print("行和验证:", np.sum(P, axis=1))  # [1., 1., 1.]

2. 高阶马尔科夫链 （捕捉时间依赖）
  1. 一阶假设有时候过于简化，预测可能不准

# 一阶模型：P(下雨|今天=晴) = 0.2
# 问题：连续10天晴天后，下雨概率还是0.2吗？

# 三阶模型更准确：
weather_probs = {
    # (前前天, 前天, 今天) → 明天天气概率
    ('晴', '晴', '晴'): {'雨': 0.6, '晴': 0.4},  # 长期晴天后更可能下雨
    ('雨', '晴', '晴'): {'雨': 0.3, '晴': 0.7},
    ('晴', '雨', '晴'): {'雨': 0.4, '晴': 0.6},
}

通用高阶实现

class HigherOrderMarkovChain:
    """τ阶马尔科夫链通用实现"""

    def __init__(self, order: int):
        self.order = order  # 记忆长度
        self.memory = []    # 存储最近order个状态

        # 转移概率表：P(X_t | X_{t-τ}, ..., X_{t-1})
        self.transitions = {}

    def add_transition(self, history: tuple, next_state: str, prob: float):
        """添加转移概率"""
        if history not in self.transitions:
            self.transitions[history] = {}
        self.transitions[history][next_state] = prob

    def predict(self) -> str:
        """基于历史预测下一个状态"""
        if len(self.memory) < self.order:
            return None

        # 获取最近的order个状态作为历史
        recent_history = tuple(self.memory[-self.order:])

        if recent_history in self.transitions:
            # 根据概率随机选择
            probs = self.transitions[recent_history]
            import random
            return random.choices(list(probs.keys()),
                                 weights=probs.values())[0]
        return None

高阶到一阶的转换技巧

• 复合状态方法 高阶马尔科夫链可以通过状态扩展转换为一阶链:

def convert_to_first_order(states: list, high_order_probs: dict, order: int):
    """
    将高阶马尔科夫链转换为等价的一阶链

    思想：将长度为order的历史序列视为一个"复合状态"
    例如：二阶链的(S,M)视为一个新状态
    """

    # 1. 创建所有可能的复合状态
    composite_states = []
    from itertools import product

    # 生成所有长度为order的状态序列
    for combo in product(states, repeat=order):
        composite_states.append(combo)

    # 2. 构建一阶转移矩阵
    n_composite = len(composite_states)
    P_first_order = np.zeros((n_composite, n_composite))

    # 3. 填充转移概率
    composite_index = {cs: i for i, cs in enumerate(composite_states)}

    for history_tuple, next_probs in high_order_probs.items():
        i = composite_index[history_tuple]

        for next_state, prob in next_probs.items():
            # 新历史：(移出最旧状态，加入新状态)
            # 例如：(S,M) + M → (M,M)
            new_history = history_tuple[1:] + (next_state,)
            j = composite_index[new_history]
            P_first_order[i, j] = prob

    return composite_states, P_first_order

# 示例：二阶链转换
states = ['S', 'M', 'C']
second_order_probs = {
    ('S', 'S'): {'S': 0.6, 'M': 0.3, 'C': 0.1},
    ('S', 'M'): {'S': 0.2, 'M': 0.6, 'C': 0.2},
    ('M', 'S'): {'S': 0.4, 'M': 0.5, 'C': 0.1},
    # ... 其他组合
}

composite_states, P_1st = convert_to_first_order(states, second_order_probs, order=2)
print(f"原始状态数: {len(states)}")
print(f"复合状态数: {len(composite_states)}")  # 3² = 9

例子:

import matplotlib.pyplot as plt
import networkx as nx
from matplotlib.patches import FancyBboxPatch

def visualize_markov_chains():
    """改进的可视化：二阶马尔科夫链转换为一阶链"""

    # 创建图形
    fig, axes = plt.subplots(1, 2, figsize=(16, 8))
    fig.suptitle('Transforming Second-Order Markov Chain to First-Order',
                fontsize=16, fontweight='bold', y=0.95)

    # ========== 左图：二阶马尔科夫链 ==========
    ax1 = axes[0]
    ax1.set_title('Second-Order Markov Chain\n(Needs memory of past 2 days)',
                 fontsize=14, fontweight='bold', pad=20)
    ax1.set_xlim(-1, 11)
    ax1.set_ylim(-1, 11)
    ax1.axis('off')

    # 时间线标签
    time_labels = ['Day -2', 'Day -1', 'Today']
    times = [2, 5, 8]

    # 绘制时间线
    ax1.plot([1.5, 8.5], [8, 8], 'k-', linewidth=2, alpha=0.7)

    for i, (time, label) in enumerate(zip(times, time_labels)):
        ax1.text(time, 8.3, label, ha='center', fontsize=11,
                fontweight='bold', color='darkblue')
        # 时间点标记
        ax1.plot(time, 8, 'ko', markersize=10)

    # 天气示例：Sunny, Sunny, Cloudy
    weather_sequence = ['Sunny', 'Sunny', 'Cloudy']
    weather_icons = {'Sunny': '☀️', 'Cloudy': '☁️', 'Rainy': '🌧️'}

    for i, (time, weather) in enumerate(zip(times, weather_sequence)):
        ax1.text(time, 7.5, weather_icons[weather], fontsize=40, ha='center')
        ax1.text(time, 7.0, weather, ha='center', fontsize=12,
                fontweight='bold', color='darkblue')

    # 依赖箭头
    ax1.arrow(times[0], 6.8, times[1]-times[0]-0.3, -0.7,
              head_width=0.15, head_length=0.2, fc='red', ec='red', alpha=0.7)
    ax1.arrow(times[1], 6.8, times[2]-times[1]-0.3, -0.7,
              head_width=0.15, head_length=0.2, fc='red', ec='red', alpha=0.7)

    # 状态空间说明
    state_space_box = FancyBboxPatch((1, 3), 8, 2,
                                    boxstyle="round,pad=0.3",
                                    facecolor="lightcoral", alpha=0.2,
                                    edgecolor="red", linewidth=1.5)
    ax1.add_patch(state_space_box)

    ax1.text(5, 4.5, 'State Space Size Problem',
            ha='center', fontsize=12, fontweight='bold', color='darkred')
    ax1.text(5, 3.8, '3 weather types → 3² = 9 possible history pairs',
            ha='center', fontsize=10, color='darkred')
    ax1.text(5, 3.3, 'P(Today | Yesterday, Day-before-yesterday)',
            ha='center', fontsize=10, color='darkred', style='italic')

    # 内存需求
    memory_box = FancyBboxPatch((1, 0.5), 8, 1.5,
                               boxstyle="round,pad=0.3",
                               facecolor="lightblue", alpha=0.2,
                               edgecolor="blue", linewidth=1.5)
    ax1.add_patch(memory_box)

    ax1.text(5, 1.7, 'Memory Requirement',
            ha='center', fontsize=12, fontweight='bold', color='darkblue')
    ax1.text(5, 1.0, 'Need to remember last 2 states',
            ha='center', fontsize=10, color='darkblue')

    # ========== 右图：转换为一阶链 ==========
    ax2 = axes[1]
    ax2.set_title('Equivalent First-Order Markov Chain\n(Composite states)',
                 fontsize=14, fontweight='bold', pad=20)
    ax2.set_xlim(-1, 11)
    ax2.set_ylim(-1, 11)
    ax2.axis('off')

    # 复合状态的概念
    composite_box = FancyBboxPatch((1, 8), 8, 2,
                                  boxstyle="round,pad=0.3",
                                  facecolor="lightgreen", alpha=0.2,
                                  edgecolor="green", linewidth=2)
    ax2.add_patch(composite_box)

    ax2.text(5, 9.5, 'Composite State = Memory Encoded in State Name',
            ha='center', fontsize=12, fontweight='bold', color='darkgreen')

    ax2.text(5, 8.8, 'Instead of: P(Weather_today | Weather_yesterday, Weather_day-before)',
            ha='center', fontsize=9, color='darkgreen')
    ax2.text(5, 8.2, 'We use: P(Composite_today | Composite_yesterday)',
            ha='center', fontsize=9, color='darkgreen')

    # 复合状态示例
    ax2.text(3, 7.0, 'Composite State Example:', ha='left', fontsize=11, fontweight='bold')

    # 状态分解图示
    # 复合状态
    comp_state = FancyBboxPatch((3, 5.5), 4, 1,
                               boxstyle="round,pad=0.3",
                               facecolor="lightblue", alpha=0.3)
    ax2.add_patch(comp_state)
    ax2.text(5, 6.0, '"Sunny-Sunny"', ha='center', fontsize=12,
            fontweight='bold', color='darkblue')
    ax2.text(5, 5.5, 'represents: Sunny yesterday + Sunny day-before',
            ha='center', fontsize=9, color='blue')

    # 箭头到天气
    ax2.arrow(5, 5.2, 0, -1, head_width=0.2, head_length=0.15,
              fc='purple', ec='purple', alpha=0.7, linestyle='--')

    # 对应天气
    weather_box = FancyBboxPatch((3, 3.5), 4, 1,
                                boxstyle="round,pad=0.3",
                                facecolor="yellow", alpha=0.2)
    ax2.add_patch(weather_box)
    ax2.text(5, 4.0, 'Actual Weather Today', ha='center', fontsize=10, fontweight='bold')
    ax2.text(5, 3.5, 'Sunny', ha='center', fontsize=14, fontweight='bold', color='darkorange')
    ax2.text(5, 3.5, '☀️', fontsize=30, ha='center')

    # 状态转移示例
    ax2.text(3, 2.5, 'State Transition Example:', ha='left', fontsize=11, fontweight='bold')

    # 转移箭头
    ax2.plot([2, 8], [2, 2], 'k-', linewidth=1, alpha=0.5)

    # 从状态 (Sunny, Sunny)
    state1_box = FancyBboxPatch((1.5, 1.2), 2, 1,
                               boxstyle="round,pad=0.3",
                               facecolor="lightblue", alpha=0.4)
    ax2.add_patch(state1_box)
    ax2.text(2.5, 1.7, 'State: (S,S)', ha='center', fontsize=10, fontweight='bold')

    # 转移箭头
    ax2.arrow(3.5, 1.7, 2, 0, head_width=0.15, head_length=0.2,
              fc='red', ec='red', alpha=0.7)

    # 到状态 (Sunny, Cloudy)
    state2_box = FancyBboxPatch((5.5, 1.2), 2, 1,
                               boxstyle="round,pad=0.3",
                               facecolor="lightblue", alpha=0.4)
    ax2.add_patch(state2_box)
    ax2.text(6.5, 1.7, 'State: (S,C)', ha='center', fontsize=10, fontweight='bold')

    # 转移概率说明
    prob_text = 'Transition Probability:\nP((S,C) | (S,S)) = 0.4'
    ax2.text(6.5, 0.5, prob_text, ha='center', fontsize=9,
            bbox=dict(boxstyle="round,pad=0.2", facecolor="yellow", alpha=0.3))

    # 关键优势
    advantage_box = FancyBboxPatch((1, -0.5), 8, 1.5,
                                  boxstyle="round,pad=0.3",
                                  facecolor="gold", alpha=0.2,
                                  edgecolor="orange", linewidth=1.5)
    ax2.add_patch(advantage_box)

    ax2.text(5, 0.0, 'Key Advantage: Standard Markov techniques apply',
            ha='center', fontsize=11, fontweight='bold', color='darkorange')
    ax2.text(5, -0.5, 'State space: 9 composite states instead of complex memory',
            ha='center', fontsize=9, color='darkorange')

    plt.tight_layout()
    plt.show()

visualize_markov_chains()

2.3 马尔科夫决策过程 (Markov Decision Process， MDP)

马尔可夫链在强化学习领域的具体应用，包括一组状态、一组动作、状态转移概率、奖励函数和折扣因子。

• 在MDP中，智能体可以选择动作，然后在环境下根据状态转移考虑确定下一个状态，并返回一个即时奖励。
• MDP的目标是找到一个最优策略，以最大化期望累计回报（或价值函数）

3. 策略函数 （Policy Function）

• 在某个state下可以选择一个具体动作action，这依赖策略函数
  • 确定性策略（Deterministic Policy）
    • 给定一个状态，策略函数输出一个动作 $$\pi(s) = a$$
  • 随机性策略（Stochastic Policy） (实际主要是这种情况)
    • 对于给定的状态，策略输出的是一个动作的概率分布 $\pi(a \mid s)$ 表示在状态 $s$ 下选择动作 $a$ 的概率。
      • 注意：在深度学习中，这个策略函数由神经网络表示
      • 所有的可能为树形结构

3.1 策略序列/轨迹 $\tau$ (trajectory)

• 状态、动作、奖励的序列

  $$\tau = (s_0, a_0, r_1, s_1, a_1, r_2, \ldots, s_{T-1}, a_{T-1}, s_T)$$

  奖励穿插在状态和动作之间。

3.2 轨迹对应的概率 $P$：

• 描述了在策略 $\theta$下，智能体agent在环境中采取一系列动作，从初始状态开始并最终达到某个终止状态的可能性有多大。这个概率分布通常用于强化学习算法中的策略优化，目标是找到使得期望回报最大化的最佳策略参数$\theta$ .

（核心是 状态-动作交替）

• 环境动态: $p(s_{t+1}|s_{t}, a_{t})$，这是环境决定的（与策略无关）
• 策略
  • 于是，一条给定轨迹的概率（假设初始状态分布为 $p(s_1)$）为： $$p_\theta(\tau) = p(s_1) \prod_{t=1}^T\pi_\theta(a_t|s_t)p(s_{t+1}|s_t, a_t)$$
    • 具体展开 $$p_\theta(\tau) = p(s_1)p_{\theta}(a_1 | s_1)p(s_2|s_1, a_1)p_{\theta}(a_2 | s_2)p(s_3|s_2, a_2)......$$

3.3 确定性策略 vs 随机策略 的轨迹分布区别

• 确定性策略只固定“给定状态时的动作”，环境转移或初始状态随机时仍存在轨迹分布；随机策略还引入动作采样的随机性
  • 确定性策略 （仅依赖环境随机）
    • 在每个状态 s 下固定输出一个特定动作，即 $$a = f(s)$$ (函数映射)
      • 在完全确定性环境 + 确定性策略时：只要初始状态固定，整条轨迹完全固定。（只有一条轨迹概率为1，其他为0）
      • 如果环境动态随机而策略确定：初始状态固定时，第一次动作固定；后续状态随机，动作随到达的状态变化，因此动作序列也未必固定。（不同轨迹的概率来自于环境随机，而不是策略随机）
  • 随机性策略（可依赖环境随机和轨迹随机）
    • 在每个状态 s 下输出动作的概率分布，例如高斯或分类分布等
      • 即使环境动态确定:$p(s_{t+1}|s_{t}, a_{t})$是确定性的，因为策略选择动作是随机的，所以从同一个初始状态出发也可以获得多条不同轨迹。
      • 如果环境也是随机的，那么此时随机性来自两者的叠加。

确定性策略本身不会因为策略的选择而随机生成多条轨迹（动作固定），随机策略会在选择动作时引入随机性，从而即使环境确定也可能有多条轨迹。因此 $p_\theta(\tau)$是一个具备更宽的概率分布，表示由于策略的随机选择导致可能有很多条轨迹，每条有不同概率。

4. 强化学习衡量 Reward 的重要指标

智能体通过与环境交互后的Reward来学习最优策略， 而累计回报、状态价值、动作价值是理解这一过程的核心逻辑链条。他们从单条路径的收益到状态的平均价值，再到动作的具体价值，层层递进刻画智能体的决策依据。

4.1 累计回报 $G_t$

• 累计回报是从时刻 t 开始， 未来所有奖励的折扣累计和，公式为： $$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 \in [0, 1]$ 是折扣因子，用于体现未来奖励的当前价值衰减；无限时域通常取 $\gamma<1$ 并要求回报可积， $\gamma$越接近0，越重视即时奖励；越接近1，越重视长期奖励
    • $R_{t+k+1}$ 是时刻 $t+k+1$的即时奖励。

4.2 状态价值 $V^{\pi}(s)$

• 状态价值函数是策略 $\pi$下，从状态 s 出发的累积回报的期望，公式为

4.3 动作价值 $Q^{\pi}(s, a)$

• 动作价值函数是在策略 $\pi$下， 从状态 s 执行动作 a 后， 累积回报的期望， 公式为 $$Q^{\pi}(s, a) = \mathbb{E}_{\pi}\left[G_t \mid S_t = s, A_t = a\right]$$ 它比状态价值更具体， 直接评估在状态 s 选动作 a ， 再按策略$\pi$行为的长期价值

4.4 $G$、$V$、$Q$ 的关系

• 状态 s 的价值， 等于在这个状态下所有可能动作的 $Q$ 值，按照你选动作的策略 $\pi$ 的概率加权平均
• 累积回报是 $Q$值和 $V$值的计算基础： $Q$值和 $V$值都是对未来累积回报的期望，因为强化学习中存在随机性（比如环境随机反馈、动作随机选择），所以要用期望来描述长期规律。

4.5 将 $G$、$V$、$Q$ 化成递推式：Bellman 方式

• 累计回报 $G_t$、状态价值 $V^{\pi}(s)$、动作价值 $Q^{\pi}(s, a)$ 都是长期价值，很难直接计算，需要遍历从当前时刻到任务结束的所有未来步骤，这在现实场景中几乎不可行。
  • 任务无终止时（如持续运行的机器人控制），未来步骤是无限的，$(G_t = \sum_{k=0}^\infty \gamma^k*R_{t+k+1})$无法直接求和。
  • 任务有终止但步骤极多（如复杂游戏通关），遍历所有未来路径的计算量会呈指数级增长，远超算力承载能力。而递推Bellman方程将无限/极多步骤的长期价值转化为当前步的奖励+下一步价值的折扣期望，只需关注当前与下一步的关联，大幅降低了计算复杂度。
  • 同时，递推式让价值学习具备迭代优化的可能。例如 Q-Learning 使用下面的更新式，让 $Q$ 值在每次交互后逐步向最优值收敛：

4.6 价值递推核心：Bellman 方程

• 强化学习中，某状态（某状态-动作对）的价值，可分解为即时奖励和后续状态的价值的折扣期望。
• Bellman方程就是用递推公式来刻画这种现在与未来的价值关联：用选择策略的回报和可达的下一状态的值描述当前状态的值。

4.6.1 Bellman期望方程：针对 $V$ 值

• 状态价值函数 $V^{\pi}(s)$的Bellman方程为

• 含义:在策略 $\pi$下, 状态 s 的价值 = 『即时奖励 $R_{t+1}$的期望』+ 『折扣后, 下一步状态 $S_{t_1}$的价值 $V^{\pi}(S_{t+1})$的期望』
• 与 $G$ 的联系:$G_t = R_{t+1} + \gamma G_{t+1}$(累积回报的递推式),而 $V^{\pi}(s) = \mathbb{E}[G_t \mid S_t = s]$,因此 Bellman 方程是对累积回报期望的递推分解。
• 为什么 $R$ 是 $t + 1$？
• 执行当前动作后, 在进入下一个状态 $S_{t+1}$的同时,才能获得对应的奖励 $R_{t+1}$
• 如何理解 $S_{t+1}$？
• 当模型有关 model-base(环境转移可推算)时:通过 $P(S_{t+1} | S_t, A_t)$可知
• 当模型无关 model-base(环境转移不可推算)时:通过下一步的真实情况采样获取 $\stackrel{-} S_{t+1}$

4.6.2 Bellman期望方程:针对 $Q$ 值

• 动作价值函数 $Q^{\pi}(s, a)$的Bellman方程为:

  $$Q^{\pi}(s, a) = \mathbb{E}_{s' \sim P} \left[ R_{t+1} + \gamma Q^{\pi}(S_{t+1}, A_{t+1}) \mid S_t = s, A_t = a \right]$$

• 含义:在策略 $\pi$下, 状态 s 的价值 = 『即时奖励 $R_{t+1}$的期望』+ 『折扣后, 转移概率 $P$给出下一步状态$S_{t+1}$通过采样选动作$A_{t+1}$的$Q$ 值的期望』

• 与 $V$ 的联系: $V^{\pi}(s) = \sum_a \pi(a|s) Q^{\pi}(S_{t+1}, A_{t+1})$, 可从 $Q$ 的Bellman方程推到得到 $V$ 的Bellman方程,体现了两者的递推一致性。

4.6.3 Bellman最优方程

• 这是表格价值迭代与 Q-Learning 分析的基础。收敛还依赖任务条件、充分访问状态动作对以及学习率条件；神经网络函数逼近不自动继承表格算法的收敛结论。

5. 无模型的学习方法:MC 与 TD

在无模型(Model-Free)场景下,我们无法依赖环境转移概率计算价值,只能通过与环境交互的经验学习。蒙特卡洛(MC)和时序差分(TD)是两种核心的无模型价值学习方法,前者依赖 “完整轨迹”,后者侧重 “单步 / 多步交互”,适用于不同场景需求。

5.1 MC 蒙特卡洛(Monte Carlo)

• 在强化学习中MC方法的本质是通过完整轨迹的累积回报,平均估计状态/动作的价值。它要求智能体完成一整个交互序列(从初始状态到终止状态),获得完整的累积回报 $G_t$ 后,再用这个真实回报更新价值:不依赖任何估计值,只基于实际交互结果。

• 关键公式

• 对于每个经历过状态 s 的轨迹, 记录该轨迹中状态 s 对应的累积回报 $G_t$, 多次交互后,状态价值的估计值为所有包含s的轨迹中 $G_t$的平均值。

  $$V(s) \leftarrow \frac{1}{N(s)} \sum_{i=1}^{N(s)} G_t^{(i)}$$

• 其中

• $N(s)$ 是包含状态 $s$ 的轨迹总数,$G_t^{(i)}$ 是第 $i$ 条轨迹中状态 $s$ 对应的累积回报。

• 对于原公式

  $$V(s) = \mathbb{E}[G_t | S_t = s]$$

• 我们发现这正是数学上蒙特卡洛算法,用暴力采样的方式,作为原复杂解的无偏估计。

• 案例

• 求圆周率

import random

def estimate_pi(num_samples, seed=42):
    if num_samples <= 0:
        raise ValueError("num_samples must be positive")
    rng = random.Random(seed)
    inside = sum(rng.uniform(-1, 1)**2 + rng.uniform(-1, 1)**2 <= 1
                 for _ in range(num_samples))
    return 4 * inside / num_samples

for n in [100, 1000, 10000, 100000]:
    estimate = estimate_pi(n)
    print(f"N={n}: pi={estimate:.6f}")

• 结果特点:
• 随机性：固定种子方便复现；大样本使估计在概率意义上更集中，但单次实验的误差不保证随 N 单调下降。
• 收敛速度:误差大致按 $1 / \sqrt {N}$ 下降,这就是蒙特卡洛的典型特征。
• 求积分

import math
import random

def mc_integral(func, a, b, num_samples, seed=42):
    if num_samples <= 0 or not a < b:
        raise ValueError("need positive samples and a < b")
    rng = random.Random(seed)
    total = sum(func(rng.uniform(a, b)) for _ in range(num_samples))
    return (b - a) * total / num_samples

for n in [1000, 10000, 100000]:
    result = mc_integral(lambda x: math.exp(-x*x), 0, 1, n)
    print(f"N={n}: integral={result:.6f}")

• 核心思想
• 把问题转换成某种随机过程的概率或期望值。
• 求 $\pi$→ 随机点落在圆内的概率
• 求积分 → 随机变量 $f(X)$的期望值,其中 $X$均匀分布
• 用大量随机样本来估计这个期望值。
• 估计的误差收敛速度是 $O(1 / \sqrt {N})$,与问题的维度无关(这是最大优点)。
• 特点与适用场景
• 优势:无偏差(仅用真实累积回报,不依赖估计值),逻辑直观,适合 “必须完成完整任务才能评估价值” 的场景(如棋类游戏、一次性决策任务)。
• 劣势:需等待轨迹终止才能更新,学习效率低；对轨迹数量要求高(需大量完整轨迹才能让平均值收敛),不适合 “无终止状态” 的持续任务(如机器人持续导航)。

5.2 TD 时序差分 (Temporal Difference)

• TD 方法结合了 MC 的 “经验采样” 和动态规划(DP)的自举(Bootstrapping)思想: 无需等待完整轨迹,每执行一步交互(获得 $S_t,A_t,R_{t+1},S_{t+1}$)后,立即用即时奖励 + 下一个状态的估计价值更新当前状态价值,是无模型场景下应用最广泛的方法。

• 比喻:学车时的“实时教练” 假设你在学开车,目标是掌握在不同路况(状态)下如何平稳驾驶(获得高回报)。

• 动态规划(DP)方法:像一个“理论派教练”。

• 他不开车,只坐在书房里研究地图和交通规则。

• 他会告诉你:“在十字路口(状态 $S$),如果你直行,根据规则,你可能会到达下一个街区(状态 $S^{'}$),而那个街区的驾驶难度评分是 X 分。所以,这个路口直行的价值是…”。

• 特点:需要世界模型(地图和规则表),完全依赖推理(自举),没有真实经验。

• 蒙特卡洛(MC)方法:像一个“事后复盘教练”。

• 他会让你开完全程(完成一个Episode),比如从家开到公司。

• 停好车后,他根据你这一趟的整体表现(是顺利到达还是磕磕碰碰)来给你一路上经过的每个路口打分。

• 特点:必须等待结局,学习是基于完整经验的,但更新延迟严重。

• 时序差分(TD)方法:像一个 “坐在副驾的实时教练”。

• 你每开过一个路口,他马上就会点评。

• 比如,刚才你平稳通过了这个拥堵路口(状态 $S_t$),得到了即时的良好感觉(即时奖励 $R_{t+1}$),并进入了下一个路口(状态 $S_{t+1}$)。教练马上说:“刚才这个路口你处理得不错！而且看,下一个路口车流也很顺畅( $S_{t+1}$ 的价值估计很高),所以我判断你刚才的选择总体价值很高。”

• 他没有等到终点,就结合了:

• 你的即时感受(奖励)

• 他对下一个路口的预判(价值估计)

• 立刻更新了你对刚才那个路口的认知。

• 特点:边走边学,实时更新,结合了真实体验片段和原有认知预测。

• 因此在每一步交互后: $S_t,A_t,R_{t+1},S_{t+1}$ 我们就立即用「即时奖励 + 下一状态的估计值」作为新的目标来更新当前状态的估计值。 这个思想其实是在逼近「期望回报」的定义式:

  $$V^{\pi}(S_t) = \mathbb{E}_{\pi}\left[ R_{t+1} + \gamma R_{t+2} + \gamma^2 R_{t+3} + \cdots \mid S_t \right]$$
  $$V^{\pi}(S_{t+1}) = \mathbb{E}_{\pi}\left[ R_{t+2} + \gamma R_{t+3} + \gamma^2 R_{t+4} + \cdots \mid S_{t+1} \right]$$

  但我们没法一次算出所有未来奖励,于是参考上面的公式用一步近似:

  $$V(S_t) \approx R_{t+1} + \gamma V(S_{t+1})$$

  这就是所谓的「自举(bootstrapping)」: 用当前估计值的一部分去更新自己。

5.2.1 核心(默认)公式

• TD (0)(单步 TD,更新状态价值):仅用 “下一步状态的估计价值” 计算更新目标,是最基础的 TD 形式:

  $$V(S_t) \leftarrow V(S_t) + \alpha\left[R_{t+1} + \gamma V(S_{t+1}) - V(S_t)\right]$$

• 其中

• $\alpha$是学习率, 决定了我们更新的幅度

• $R_{t+1} + \gamma V(S_{t+1})$成为TD目标

• $R_{t+1} + \gamma V(S_{t+1}) - V(S_t)$是TD误差, 衡量当前估计与目标的差距

• 同时, 它还可以用于 $Q(s, a)$的递推.(sarsa算法)

5.2.2 SARSA (更新动作价值,On-Policy TD控制算法)

名称来源于 $S_t,A_t,R_{t+1},S_{t+1}, A_{t+1}$

• 针对动作价值 $Q(s, a)$, 更新时依赖实际执行的下一个动作 $A_{t+1}$ :

  $$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]$$

• 其中

• $R_{t+1} + \gamma Q(S_{t+1}, A_{t+1})$被称为 TD目标

• $R_{t+1} + \gamma Q(S_{t+1}, A_{t+1}) - Q(S_t, A_t)$ 被称为 TD 误差(TD error)。

• 我们定义其更新目标(监督信号或标签)为:

  $$y_t = R_{t+1} + \gamma Q(S_{t+1}, A_{t+1})$$

• TD目标,它代表了当前状态-动作的理想预测值

• SARSA是一种 On-policy 学习算法:每次更新都基于智能体在当前策略下实际执行的下一步动作 $A_{t+1}$

6. 价值函数算法

6.1 Q-Learning

• Q-Learning 是一种典型的异策略（Off-Policy）时序差分(TD)强化学习算法。其核心目标是学习一个最优的动作价值函数 $Q^{*}(s, a)$,该函数表示在状态s下采取动作a后,遵循最优策略所能获得的期望累计折扣回报

6.1.1 算法流程

• 初始化

• 创建一个表格,存储所有 $(s, a)$组合的 $Q$值,为所有状态-动作对赋予初始值

• 交互与更新

• 在每个时间步 $t$,智能体在状态 $S_t$下根据某种策略(贪心算法等)选择动作 $A_t$

• 执行动作

• 执行动作 $A_t$,环境返回奖励 $R_{t+1}$和下一个状态 $S_{t+1}$

• 更新$Q$值,也可以用收敛快的启发式算法得出

  $$Q^*(s, a) = \mathbb{E}\left[ R_{t+1} + \gamma \max_{a'} Q^*(S_{t+1}, a') \mid S_t = s, A_t = a \right]$$

• 重复

• 令 $S_t \leftarrow S_{t+1}$,重复2-4步骤,直至 $Q$表收敛 这样就可以反复迭代更新每个情况s下每一种动作a的动作价值 $Q$

6.1.2 (查表)决策

最终优化好了 $Q$ 值表后,选择当前状态下 $Q$ 值最大的动作,通过查训练好的$Q$值表快速到达终点。

6.2 SARSA 和 Q-Learning 的对比测试

• Code :

import numpy as np

# 4x12：起点 36，终点 47，悬崖 37..46。
# 掉崖奖励 -100 并回到起点，但 episode 不终止；到达终点才终止。
def step(state, action):
    row, col = divmod(state, 12)
    dr, dc = [(-1, 0), (0, 1), (1, 0), (0, -1)][action]
    row, col = np.clip(row + dr, 0, 3), np.clip(col + dc, 0, 11)
    next_state = int(row * 12 + col)
    if 37 <= next_state <= 46:
        return 36, -100.0, False
    return next_state, -1.0, next_state == 47

def epsilon_greedy(q, state, rng, epsilon):
    if rng.random() < epsilon:
        return int(rng.integers(4))
    choices = np.flatnonzero(q[state] == q[state].max())
    return int(rng.choice(choices))

def train(method, episodes=500, seed=42, alpha=0.5, gamma=1.0, epsilon=0.1):
    if method not in ("sarsa", "q_learning"):
        raise ValueError("unknown method")
    rng = np.random.default_rng(seed)
    q = np.zeros((48, 4))
    returns = []
    for _ in range(episodes):
        state, total = 36, 0.0
        action = epsilon_greedy(q, state, rng, epsilon)
        for _ in range(10000):
            next_state, reward, terminated = step(state, action)
            next_action = epsilon_greedy(q, next_state, rng, epsilon)
            bootstrap = (q[next_state, next_action] if method == "sarsa"
                         else q[next_state].max())
            target = reward + gamma * (0.0 if terminated else bootstrap)
            q[state, action] += alpha * (target - q[state, action])
            total += reward
            if terminated:
                break
            state, action = next_state, next_action
        else:
            raise RuntimeError("episode exceeded the demonstration step budget")
        returns.append(total)
    return q, np.array(returns)

if __name__ == "__main__":
    for method in ("sarsa", "q_learning"):
        _, returns = train(method)
        print(method, "last-100 mean return:", returns[-100:].mean())

上方两张图保留历史实验的路径与回报对比，不是当前精简代码的固定输出。运行代码会打印所选种子的末 100 回合平均回报；多种子实验才适合比较稳定性。

6.3 $Q$ 值过估计(Overrstimation Bias)

6.3.1 问题定义

• 同一组带噪声估计同时用于选择最大动作与评估其价值时，会产生最大化偏差；但不能断言每个训练阶段、每个状态动作的估计都高于 Q*。

6.3.2 产生原因

• 纯价值函数方法容易产生价值过估计,原因出在迭代过程中的取最大动作价值$Q$,在于更新公式中 $\max$ 操作和估计误差的结合。

• 更新公式

  $$Q(s,a)\leftarrow Q(s,a)+\alpha\left[r+\gamma(1-d)\max_{a'}Q(s',a')-Q(s,a)\right]$$

  其中 α 是学习率，d 表示真正终止；时间限制截断不能一概当作终止。

• 采样时

  $$Q^{d}(s^{'}, a^{'}) = Q^{*}(s^{'}, a^{'}) + \epsilon_{a^{'}}$$

• 其中 $\epsilon_{a^{'}}$是估计误差,可能正或可能负,由于$\max$操作倾向于选择误差最大的那个动作,很可能存在某个样本导致:

  $$\mathbb{E} [\max_{a^{'}} Q^{d}(s^{'}, a^{'})] > \max_{a^{'}} Q^{*}(s^{'}, a^{'})$$

• 因此,纯价值函数方法(如Q-Learning、DQN)天然容易出现过估计

• Actor-Critic 将动作生成与价值评估分开，但 Actor 仍依赖 Critic 的估计，因此结构本身不能消除过估计。TD3 的双 Critic 取小目标和延迟更新才是针对性机制，见 TD3 官方说明。

6.4 从最大化偏差到 Double Q-Learning

下面先隔离“同一组带噪声估计既选择又评估动作”这一机制。所有动作的真实价值设为零；这个统计实验不是完整的强化学习训练，也不能证明任意环境中 Double Q 的回报一定更高。

import numpy as np

rng = np.random.default_rng(42)
selector = rng.normal(size=(100000, 10))
evaluator = rng.normal(size=selector.shape)
chosen = selector.argmax(axis=1)
coupled = selector[np.arange(len(selector)), chosen]
decoupled = evaluator[np.arange(len(selector)), chosen]
print("same estimator:", coupled.mean())
print("independent evaluator:", decoupled.mean())

def double_q_update(q1, q2, state, action, reward, next_state,
                    terminated, rng, alpha=0.1, gamma=0.99):
    """两个同形状二维 Q 表；随机更新其中一个，另一个负责评估。"""
    select, evaluate = (q1, q2) if rng.random() < 0.5 else (q2, q1)
    target = reward
    if not terminated:
        next_action = int(np.argmax(select[next_state]))
        target += gamma * evaluate[next_state, next_action]
    select[state, action] += alpha * (target - select[state, action])

训练时可用 q1 + q2 形成 ε-greedy 行为策略。两个表由同一条经验流学习，并不严格统计独立；Double Q 将动作选择与评估解耦，缓解最大化偏差，但仍可能低估，不能保证偏差永远为零。

以上保留的两张图来自历史实验，并非上方精简示例的本次运行结果。曲线差异受到环境、随机种子、训练预算和估计器相关性的影响，不据单次试验宣称固定提升比例。

6.5 DQN (Deep Q-Network 使用神经网络的Q-Learning)

• 核心思想
• 一旦S和A的组合增加,Q值表的计算和存储的开销都会很大。用深度学习网络近似Q函数,通过输入状态 s 直接预测所有动作 a 的 Q 值,解决传统Q-Learning在高维状态空间下的"维数灾难"问题。

• 输入维度:适应高维状态

• 输出维度:等于离散动作空间的尺寸

• DQN 的逻辑:拟合 Q 值,间接生成策略

• 神经网络的角色：用深度神经网络拟合 Q(s,a)，输入是状态 s(如游戏画面),输出是所有动作的 Q 值(如 “向左走的 Q 值、向右走的 Q 值”)。

• 一次反向传播用到的数据: $s_t,a_t,r_{t+1},s_{t+1}$

• 反向传播只回归当前采样动作对应的标量 Q(s,a)，不是把所有动作输出当作同一个目标向量。TD 目标由目标网络计算并停止梯度；真终止时目标只有奖励。

• 策略的生成:训练完成后,策略是 “选 Q 值最大的动作”(贪心策略),策略由 Q 值间接推导,而非网络直接输出动作概率。

• 训练机制

• 前向传播: 输入状态 $s_t$ -> 网络 -> 得到所有动作的预测Q值

• 选择动作: ε-greedy(训练时)或 greedy策略(测试时)

• 执行动作: 获得奖励 $r_{t+1}$和新状态 $S_{t+1}$

• 计算目标：

  $$y = R + \gamma(1-d)\max_{a'}Q(s', a'; \theta')$$

• 反向传播：更新 θ，最小化 (y - Q(s,a;θ))² 或对应 Huber 损失，而不是有符号误差本身。下方回放与目标网络代码块是流程伪代码。

• 关键技术： DQN 通过经验回放（Experience Replay）和目标网络（Target Network）等技术解决了 Q-learning 中样本相关性和目标值不稳定的问题。

• 经验回放

# 传统Q-Learning问题：序列样本强相关
for (s, a, r, s') in sequential_experience:
update(Q)  # 连续相关样本 → 训练不稳定
# DQN解决方案：经验回放
replay_buffer.append((s, a, r, s'))
batch = random.sample(replay_buffer, k)  # 随机采样 → 打破相关性
update(Q)  # 稳定训练

• 目标网络

# 传统问题：目标值y与预测值Q来自同一网络
y = r + γ * max Q(s', a'; θ)  # θ快速变化 → 目标值波动大
# DQN解决方案：固定目标网络
y = r + γ * max Q(s', a'; θ^-)  # θ^-每N步同步一次θ → 目标稳定

• 总结：

• Q-Learning：仅适用于低维离散状态 / 动作（如 10×10 网格世界）
• DQN：可处理高维状态（如图像、传感器数据），但动作仍需是离散的（如 Atari 游戏的上下左右按键）
• 因此，DQN标志着深度强化学习时代的开启，将深度学习的表示能力与强化学习的决策框架相结合，实现了从低维表格到高维函数逼近的跨越，为处理真实世界复杂问题奠定了基础。

7. 策略梯度算法(Policy Gradient, PG)

• 价值学习: 先学习价值函数（Q-learning、DQN等），再根据价值选择动作。
• 策略梯度: 直接学习一个参数化的策略函数 $\pi_{\theta}(a | s)$，输出动作的概率分布，通过梯度上升直接优化策略参数。

7.1 策略梯度的数学形式

• 目标函数

• 目标是最大化期望回报

  $$J(\theta) = \mathbb{E}_{\tau \sim {\pi}_{\theta}}(R(\tau))$$

• 其中 $\tau$ 是轨迹 $(s_0, a_0, r_0, s_1, a_1,....)$， $R(\tau)$是轨迹的总回报。

• 策略梯度定理

• 梯度表达式为

  $$\nabla_{\theta}J(\theta) = \mathbb{E}_{\tau \sim {\pi}_{\theta}}[\sum^T_{t=0} \nabla_{\theta}\log \pi_{\theta}(a_t | s_t) * G_t]$$

• 其中 $G_t = \sum^T_{k=t}\gamma^{k-t}r_k$是从时刻 $t$开始的累积回报。

7.2 强化学习梯度的反向传播

• 策略梯度适用于可微的参数化策略，不要求策略一定是神经网络；反向传播是计算复杂组合函数梯度的工具。
• 策略梯度和深度学习里面的梯度基本上是一样的，都是用来找更优解：以蒙特卡洛的思路，利用真实的样本采样来更新模型参数，计算回报对策略参数的梯度，通过梯度上升更新参数，让高回报动作出现概率增加。

7.3 优化目标与学习信号的区别

• 传统神经网络的反向传播

• 监督学习：数据 -> 预测 -> 误差 -> 梯度下降

• 监督学习梯度 = 误差 × 输入特征

• 监督学习只看当前样本 传统网络的梯度来源于误差，目标是减小误差，所以是梯度下降。

• 策略神经网络的反向传播

• 强化学习：状态 -> 动作 -> 奖励 -> 回报 -> 梯度上升
• 策略梯度 = 回报 × (增加当前动作概率的方向)
• 强化学习必须考虑整个轨迹的长期回报
• 策略网络的梯度来源于回报，目标是增大回报，所以是梯度上升。其梯度公式可以看作是用回报 $G_t$对提高动作概率的梯度进行加权。
• 策略梯度不是简单地「把梯度下降变成梯度上升」，而是将优化范式从「误差最小化」转变为「期望最大化」，从而解决了传统方法无法处理的序列决策和环境交互问题。

7.4 REINFORCE算法和策略梯度定理

7.4.1 REINFORCE的核心突破

• 核心问题解决：如何直接优化策略
• 在REINFORCE之前，强化学习主要基于价值函数（如Q-learning）。REINFORCE开创了直接策略优化的新范式：
• 传统方法：价值函数 → 策略（间接）
• REINFORCE：直接优化策略参数

7.4.2 关键数学工具：对数导数技巧（Log-Derivative Trick）

# 问题：无法直接对采样期望求导
∇_θ E_{τ∼p_θ}[R(τ)] = ?
# 解决方案：对数导数技巧
∇_θ E_{τ∼p_θ}[R(τ)] = E_{τ∼p_θ}[R(τ) · ∇_θ log p_θ(τ)]
# 然后分解轨迹概率
∇_θ log p_θ(τ) = Σ_t ∇_θ log π_θ(a_t|s_t)

7.4.3 策略梯度定理的完整推导

• 马尔可夫决策过程（MDP）定义

• MDP五元组

  $$\mathcal{M} = (\mathcal{S}, \mathcal{A}, P, r, \gamma)$$

• 各元素含义：

• $\mathcal{S}$：状态空间（State Space）

• $\mathcal{A}$：动作空间（Action Space）

• $P(s'|s,a)$：状态转移概率

• $r(s,a)$：奖励函数

• $\gamma \in [0,1]$：折扣因子

• 参数化策略

  $$\pi_\theta(a|s)$$

  表示策略 其中 $\theta$是策略参数，通常为神经网络权重。

• 轨迹定义

• 一条完整轨迹：

  $$\tau = (s_0, a_0, s_1, a_1, \dots, s_T, a_T)$$

• 轨迹的概率分布：

  $$p_\theta(\tau) = \rho(s_0) \prod_{t=0}^{T} \pi_\theta(a_t|s_t) P(s_{t+1}|s_t, a_t)$$

• 各部分的含义：

• $\rho(s_0)$：初始状态分布

• $\pi_\theta(a_t|s_t)$：策略选择的动作概率

• $P(s_{t+1}|s_t, a_t)$：环境状态转移概率

• 目标函数

• 折扣回报：

  $$R(\tau) = \sum_{t=0}^{T} \gamma^t r(s_t, a_t)$$

• 期望回报（目标函数）：

  $$J(\theta) = \mathbb{E}_{\tau \sim p_\theta}[R(\tau)] = \int p_\theta(\tau) R(\tau) \, d\tau$$

• 梯度计算的核心问题

• 梯度表达式

  $$\nabla_\theta J(\theta) = \nabla_\theta \mathbb{E}_{\tau \sim p_\theta}[R(\tau)]$$

• 直接计算的困境

  $$\nabla_\theta J(\theta) = \nabla_\theta \int p_\theta(\tau) R(\tau) \, d\tau$$

• 问题分析：

• 梯度算子 $\nabla_\theta$ 同时作用于：

• 分布 $p_\theta(\tau)$（与 $\theta$ 相关）

• 回报 $R(\tau)$（通常与 $\theta$ 无关）

• 无法直接对概率分布求导

• 对数导数技巧（Log-Derivative Trick）

• 为什么要取对数？

• 乘法变加法：更容易处理

• 避免数值下溢：概率相乘会变得极小

• 求导方便：对数和求导更简单

• 技巧定义

• 对于任意可微的概率密度函数 $p_\theta(x)$：

• 核心公式：

  $$\nabla_\theta p_\theta(x) = p_\theta(x) \cdot \nabla_\theta \log p_\theta(x)$$

• 证明过程

  $$\begin{aligned} &\text{已知：} \log p_\theta(x) = \ln p_\theta(x) \\ &\text{两边对 } \theta \text{ 求导：} \\ &\nabla_\theta \log p_\theta(x) = \frac{1}{p_\theta(x)} \nabla_\theta p_\theta(x) \\ &\text{整理得：} \\ &\nabla_\theta p_\theta(x) = p_\theta(x) \cdot \nabla_\theta \log p_\theta(x) \end{aligned}$$

• 策略梯度定理推导

• 应用对数导数技巧

• 步骤1：交换积分与梯度

  $$\nabla_\theta J(\theta) = \int \nabla_\theta p_\theta(\tau) R(\tau) \, d\tau$$

• 步骤2：应用对数导数技巧

  $$= \int \left[ p_\theta(\tau) \cdot \nabla_\theta \log p_\theta(\tau) \right] R(\tau) \, d\tau$$

• 步骤3：整理为期望形式

  $$= \int p_\theta(\tau) \left[ \nabla_\theta \log p_\theta(\tau) \cdot R(\tau) \right] \, d\tau$$
  $$= \mathbb{E}_{\tau \sim p_\theta} \left[ \nabla_\theta \log p_\theta(\tau) \cdot R(\tau) \right]$$

• 分解轨迹概率的对数

• 展开 $\log p_\theta(\tau)$：（公式分解 按照log对数运算规则以及连乘转求和）

  $$\begin{aligned} \log p_\theta(\tau) &= \log \left[ \rho(s_0) \prod_{t=0}^{T} \pi_\theta(a_t|s_t) P(s_{t+1}|s_t, a_t) \right] \\ &= \log \rho(s_0) + \sum_{t=0}^{T} \log \pi_\theta(a_t|s_t) + \sum_{t=0}^{T} \log P(s_{t+1}|s_t, a_t) \end{aligned}$$

• 对 $\theta$ 求梯度：

  $$\nabla_\theta \log p_\theta(\tau) = \nabla_\theta \left[ \log \rho(s_0) + \sum_{t=0}^{T} \log \pi_\theta(a_t|s_t) + \sum_{t=0}^{T} \log P(s_{t+1}|s_t, a_t) \right]$$

• 分析各项：

• $\nabla_\theta \log \rho(s_0) = 0$（初始状态分布与环境有关, 与 $\theta$ 无关）

• $\nabla_\theta \log P(s_{t+1}|s_t, a_t) = 0$（环境转移概率是环境特性, 与 $\theta$ 无关）

• $\nabla_\theta \log \pi_\theta(a_t|s_t) \neq 0$（这是策略部分, 由参数 $\theta$控制）

• 简化结果：

  $$\nabla_\theta \log p_\theta(\tau) = \sum_{t=0}^{T} \nabla_\theta \log \pi_\theta(a_t|s_t)$$

• 得到最终定理 代入梯度表达式：

  $$\nabla_\theta J(\theta) = \nabla_\theta \mathbb{E}_{\tau \sim p_\theta}[R(\tau)]$$
  $$\nabla_\theta J(\theta) = \mathbb{E}_{\tau \sim p_\theta} \left[ \left( \sum_{t=0}^{T} \nabla_\theta \log \pi_\theta(a_t|s_t) \right) \cdot R(\tau) \right]$$

  最终形式：

  $$\boxed{\nabla_\theta J(\theta) = \mathbb{E}_{\tau \sim p_\theta} \left[ \sum_{t=0}^{T} \nabla_\theta \log \pi_\theta(a_t|s_t) \cdot R(\tau) \right]}$$