策略梯度方法详解

引言#

在强化学习中，我们希望智能体学会做出最优决策以最大化累积奖励。学习最优策略主要有两大思路：

基于值函数的方法（如 Q-learning、DQN）：先学习状态-动作的价值，再从中推导出策略
策略梯度方法（Policy Gradient）：直接优化策略本身

策略梯度方法的核心优势：

✅ 能处理高维或连续动作空间（如机器人控制）
✅ 能学习随机策略（在某些游戏中必需，如石头剪刀布）
✅ 收敛性更好（在理论和实践中）
✅ 可以更自然地融入先验知识

本文将深入讲解策略梯度的数学原理，详细推导 REINFORCE 算法，探讨方差降低技术（baseline、GAE等），并通过 CartPole 和 MuJoCo 环境的完整代码展示实战应用。

1. 策略梯度基础理论#

1.1 核心概念回顾#

策略（Policy）：从状态到动作的映射，记为 $\pi_\theta(a|s)$

确定性策略： $a = \mu_\theta(s)$
随机性策略： $a \sim \pi_\theta(\cdot|s)$

目标函数（Objective）：期望累积奖励

J(\theta) = E_{\tau \sim \pi_\theta} \left[ \sum_{t=0}^T \gamma^t r_t \right] = E_{\tau \sim \pi_\theta} [R(\tau)]

其中轨迹 $\tau = (s_0, a_0, r_0, s_1, a_1, r_1, \ldots)$

策略梯度的目标：找到 $\theta^* = \arg\max_\theta J(\theta)$

1.2 策略梯度定理（Policy Gradient Theorem）#

核心问题：如何计算 $\nabla_\theta J(\theta)$ ？

直观困难：

期望包含环境动态 $P(s'|s,a)$ ，我们通常不知道
轨迹分布 $p_\theta(\tau)$ 依赖于 $\theta$

突破性结果（Sutton et al., 1999）：

\nabla_\theta J(\theta) = E_{\tau \sim \pi_\theta} \left[ \sum_{t=0}^T \nabla_\theta \log \pi_\theta(a_t|s_t) \cdot R_t \right]

其中 $R_t = \sum_{k=t}^T \gamma^{k-t} r_k$ 是从时刻 $t$ 开始的累积回报。

关键洞察：

梯度不依赖于环境动态 $P(s'|s,a)$ （因果性 log derivative trick）
可以通过采样轨迹来估计梯度
$\log \pi_\theta$ 的梯度可以通过自动微分轻松计算

1.3 策略梯度定理的直观解释#

\nabla_\theta J(\theta) \propto \sum_{s,a} \rho^\pi(s) \cdot \nabla_\theta \pi_\theta(a|s) \cdot Q^\pi(s,a)

解读：

在状态 $s$ 下，如果动作 $a$ 有高 Q 值，增加选择 $a$ 的概率
如果动作 $a$ 有低 Q 值（甚至负值），减少选择 $a$ 的概率
访问频率 $\rho^\pi(s)$ 自然加权

类比：类似于监督学习中的交叉熵损失，但标签是由环境反馈的奖励决定的。

1.4 数学推导（可选深入）#

符号定义：

轨迹 $\tau = (s_0, a_0, s_1, a_1, \ldots, s_T)$
轨迹概率： $p_\theta(\tau) = \rho_0(s_0) \prod_{t=0}^{T-1} \pi_\theta(a_t|s_t) P(s_{t+1}|s_t, a_t)$
轨迹回报： $R(\tau) = \sum_{t=0}^T \gamma^t r_t$

推导步骤：

\begin{align} \nabla_\theta J(\theta) &= \nabla_\theta E_{\tau \sim p_\theta} [R(\tau)] \\ &= \nabla_\theta \int p_\theta(\tau) R(\tau) d\tau \\ &= \int \nabla_\theta p_\theta(\tau) R(\tau) d\tau \\ &= \int p_\theta(\tau) \nabla_\theta \log p_\theta(\tau) R(\tau) d\tau \quad \text{(log derivative trick)} \\ &= E_{\tau \sim p_\theta} [\nabla_\theta \log p_\theta(\tau) \cdot R(\tau)] \end{align}

展开 $\log p_\theta(\tau)$ ：

\log p_\theta(\tau) = \log \rho_0(s_0) + \sum_{t=0}^{T-1} \log \pi_\theta(a_t|s_t) + \sum_{t=0}^{T-1} \log P(s_{t+1}|s_t, a_t)

关键步骤：求梯度时，只有 $\pi_\theta$ 依赖于 $\theta$ ，其他项梯度为 0：

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

最终形式：

\nabla_\theta J(\theta) = E_{\tau \sim \pi_\theta} \left[ \sum_{t=0}^{T-1} \nabla_\theta \log \pi_\theta(a_t|s_t) \cdot R(\tau) \right]

进一步优化（利用因果性）：时刻 $t$ 的动作不影响过去的奖励，因此：

\nabla_\theta J(\theta) = E_{\tau \sim \pi_\theta} \left[ \sum_{t=0}^{T-1} \nabla_\theta \log \pi_\theta(a_t|s_t) \cdot R_t \right]

其中 $R_t = \sum_{k=t}^{T-1} \gamma^{k-t} r_k$ 。

2. REINFORCE 算法#

2.1 算法原理#

REINFORCE（Williams, 1992）是最经典的策略梯度算法，直接实现策略梯度定理。

核心思想：Monte Carlo 采样估计梯度。

算法流程：

初始化策略参数 $\theta$
重复：
- 使用当前策略 $\pi_\theta$ 采样一条完整轨迹 $\tau = (s_0, a_0, r_0, \ldots, s_T)$
- 计算每个时刻的累积回报 $R_t$
- 更新策略参数： $\theta \leftarrow \theta + \alpha \sum_{t=0}^T \nabla_\theta \log \pi_\theta(a_t|s_t) \cdot R_t$

2.2 伪代码#

1
算法：REINFORCE
2

3
输入：可微策略 π_θ
4
参数：学习率 α, 折扣因子 γ
5

6
初始化：策略参数 θ（随机或预设）
7

8
for episode = 1, 2, ... do
9
    生成一条轨迹 τ = {s_0, a_0, r_0, ..., s_T} 使用 π_θ
10

11
    for t = 0 to T do
12
        计算回报 R_t = Σ_{k=t}^T γ^{k-t} * r_k
13
        计算梯度 g_t = ∇_θ log π_θ(a_t | s_t) * R_t
14
        累积梯度 Δθ += g_t
15
    end for
16

17
    更新参数 θ ← θ + α * Δθ
18
end for

2.3 CartPole 完整实现#

1
import gym
2
import numpy as np
3
import torch
4
import torch.nn as nn
5
import torch.optim as optim
6
from torch.distributions import Categorical
7
import matplotlib.pyplot as plt
8

9
# 定义策略网络
10
class PolicyNetwork(nn.Module):
11
    def __init__(self, input_dim, hidden_dim, output_dim):
12
        super(PolicyNetwork, self).__init__()
13
        self.fc = nn.Sequential(
14
            nn.Linear(input_dim, hidden_dim),
15
            nn.ReLU(),
16
            nn.Linear(hidden_dim, hidden_dim),
17
            nn.ReLU(),
18
            nn.Linear(hidden_dim, output_dim),
19
            nn.Softmax(dim=-1)
20
        )
21

22
    def forward(self, x):
23
        return self.fc(x)
24

25
# REINFORCE 智能体
26
class REINFORCEAgent:
27
    def __init__(self, state_dim, action_dim, hidden_dim=128, lr=1e-3, gamma=0.99):
28
        self.gamma = gamma
29
        self.policy = PolicyNetwork(state_dim, hidden_dim, action_dim)
30
        self.optimizer = optim.Adam(self.policy.parameters(), lr=lr)
31

32
        # 存储轨迹
33
        self.log_probs = []
34
        self.rewards = []
35

36
    def select_action(self, state):
37
        """根据当前策略选择动作"""
38
        state = torch.FloatTensor(state).unsqueeze(0)
39
        probs = self.policy(state)
40
        dist = Categorical(probs)
41
        action = dist.sample()
42

43
        # 保存 log π(a|s)
44
        self.log_probs.append(dist.log_prob(action))
45

46
        return action.item()
47

48
    def compute_returns(self):
49
        """计算每个时刻的累积回报 R_t"""
50
        returns = []
51
        R = 0
52
        for r in reversed(self.rewards):
53
            R = r + self.gamma * R
54
            returns.insert(0, R)
55

56
        # 标准化回报（减少方差）
57
        returns = torch.tensor(returns)
58
        returns = (returns - returns.mean()) / (returns.std() + 1e-8)
59

60
        return returns
61

62
    def update(self):
63
        """更新策略参数"""
64
        returns = self.compute_returns()
65

66
        policy_loss = []
67
        for log_prob, R in zip(self.log_probs, returns):
68
            # 负号：因为 PyTorch 做梯度下降，我们要梯度上升
69
            policy_loss.append(-log_prob * R)
70

71
        # 反向传播
72
        self.optimizer.zero_grad()
73
        policy_loss = torch.stack(policy_loss).sum()
74
        policy_loss.backward()
75
        self.optimizer.step()
76

77
        # 清空轨迹缓存
78
        self.log_probs = []
79
        self.rewards = []
80

81
        return policy_loss.item()
82

83
# 训练函数
84
def train_reinforce(env_name='CartPole-v1', n_episodes=1000, max_steps=500):
85
    env = gym.make(env_name)
86
    state_dim = env.observation_space.shape[0]
87
    action_dim = env.action_space.n
88

89
    agent = REINFORCEAgent(state_dim, action_dim)
90

91
    episode_rewards = []
92
    episode_losses = []
93

94
    for episode in range(n_episodes):
95
        state, _ = env.reset()
96
        episode_reward = 0
97

98
        for step in range(max_steps):
99
            # 选择动作
100
            action = agent.select_action(state)
101

102
            # 执行动作
103
            next_state, reward, terminated, truncated, _ = env.step(action)
104
            done = terminated or truncated
105

106
            # 存储奖励
107
            agent.rewards.append(reward)
108
            episode_reward += reward
109

110
            state = next_state
111

112
            if done:
113
                break
114

115
        # 更新策略
116
        loss = agent.update()
117

118
        episode_rewards.append(episode_reward)
119
        episode_losses.append(loss)
120

121
        if (episode + 1) % 100 == 0:
122
            avg_reward = np.mean(episode_rewards[-100:])
123
            print(f"Episode {episode+1}, Avg Reward: {avg_reward:.2f}, Loss: {loss:.4f}")
124

125
    env.close()
126

127
    return episode_rewards, episode_losses, agent
128

129
# 训练
130
rewards, losses, trained_agent = train_reinforce()
131

132
# 可视化学习曲线
133
fig, axes = plt.subplots(1, 2, figsize=(14, 5))
134

135
axes[0].plot(rewards, alpha=0.3, label='Raw')
136
axes[0].plot(np.convolve(rewards, np.ones(100)/100, mode='valid'), label='Moving Avg (100)')
137
axes[0].set_xlabel('Episode')
138
axes[0].set_ylabel('Total Reward')
139
axes[0].set_title('REINFORCE Training on CartPole')
140
axes[0].legend()
141
axes[0].grid(True, alpha=0.3)
142

143
axes[1].plot(losses, alpha=0.5)
144
axes[1].set_xlabel('Episode')
145
axes[1].set_ylabel('Policy Loss')
146
axes[1].set_title('Policy Loss over Time')
147
axes[1].grid(True, alpha=0.3)
148

149
plt.tight_layout()
150
plt.show()

2.4 测试训练好的策略#

1
def test_policy(agent, env_name='CartPole-v1', n_episodes=10, render=True):
2
    """测试训练好的策略"""
3
    env = gym.make(env_name, render_mode='human' if render else None)
4

5
    test_rewards = []
6

7
    for episode in range(n_episodes):
8
        state, _ = env.reset()
9
        episode_reward = 0
10
        done = False
11

12
        while not done:
13
            # 确定性策略：选择概率最高的动作
14
            state_tensor = torch.FloatTensor(state).unsqueeze(0)
15
            with torch.no_grad():
16
                probs = agent.policy(state_tensor)
17
            action = torch.argmax(probs).item()
18

19
            state, reward, terminated, truncated, _ = env.step(action)
20
            done = terminated or truncated
21
            episode_reward += reward
22

23
        test_rewards.append(episode_reward)
24
        print(f"Test Episode {episode+1}: Reward = {episode_reward}")
25

26
    env.close()
27

28
    print(f"\nAverage Test Reward: {np.mean(test_rewards):.2f} ± {np.std(test_rewards):.2f}")
29

30
    return test_rewards
31

32
# 测试
33
test_policy(trained_agent, n_episodes=5, render=False)

3. 方差降低技术#

3.1 高方差问题#

REINFORCE 的主要问题：梯度估计的方差非常高。

原因分析：

Monte Carlo 估计本身方差大
累积回报 $R_t$ 波动大
高方差 → 学习不稳定、需要大量样本

3.2 Baseline 技术#

核心思想：从回报中减去一个基准值，减少方差而不引入偏差。

理论保证：对于任意只依赖状态的函数 $b(s)$ ，有

E_{\pi_\theta} \left[ \nabla_\theta \log \pi_\theta(a|s) \cdot b(s) \right] = 0

修改后的梯度：

\nabla_\theta J(\theta) = E_{\tau} \left[ \sum_{t=0}^T \nabla_\theta \log \pi_\theta(a_t|s_t) \cdot (R_t - b(s_t)) \right]

常见 Baseline 选择：

平均回报： $b = \frac{1}{N} \sum_i R_i$
状态值函数： $b(s) = V^\pi(s)$ （最优）
移动平均： $b_t = \alpha \cdot b_{t-1} + (1-\alpha) \cdot R_t$

3.3 带 Baseline 的 REINFORCE 实现#

1
class REINFORCEWithBaseline:
2
    def __init__(self, state_dim, action_dim, hidden_dim=128, lr_policy=1e-3, lr_value=1e-3, gamma=0.99):
3
        self.gamma = gamma
4

5
        # 策略网络
6
        self.policy = PolicyNetwork(state_dim, hidden_dim, action_dim)
7
        self.policy_optimizer = optim.Adam(self.policy.parameters(), lr=lr_policy)
8

9
        # 值函数网络（作为 baseline）
10
        self.value_net = nn.Sequential(
11
            nn.Linear(state_dim, hidden_dim),
12
            nn.ReLU(),
13
            nn.Linear(hidden_dim, hidden_dim),
14
            nn.ReLU(),
15
            nn.Linear(hidden_dim, 1)
16
        )
17
        self.value_optimizer = optim.Adam(self.value_net.parameters(), lr=lr_value)
18

19
        # 轨迹缓存
20
        self.log_probs = []
21
        self.rewards = []
22
        self.states = []
23
        self.values = []
24

25
    def select_action(self, state):
26
        """选择动作并估计状态值"""
27
        state_tensor = torch.FloatTensor(state).unsqueeze(0)
28

29
        # 策略网络
30
        probs = self.policy(state_tensor)
31
        dist = Categorical(probs)
32
        action = dist.sample()
33
        self.log_probs.append(dist.log_prob(action))
34

35
        # 值函数网络
36
        value = self.value_net(state_tensor)
37
        self.values.append(value)
38

39
        self.states.append(state)
40

41
        return action.item()
42

43
    def update(self):
44
        """更新策略和值函数"""
45
        # 计算累积回报
46
        returns = []
47
        R = 0
48
        for r in reversed(self.rewards):
49
            R = r + self.gamma * R
50
            returns.insert(0, R)
51
        returns = torch.tensor(returns).unsqueeze(1)
52

53
        # 转换为张量
54
        values = torch.cat(self.values)
55
        log_probs = torch.stack(self.log_probs)
56

57
        # 计算优势函数 A(s,a) = R - V(s)
58
        advantages = returns - values.detach()
59

60
        # 更新策略网络
61
        policy_loss = -(log_probs * advantages).mean()
62
        self.policy_optimizer.zero_grad()
63
        policy_loss.backward()
64
        self.policy_optimizer.step()
65

66
        # 更新值函数网络（均方误差）
67
        value_loss = nn.MSELoss()(values, returns)
68
        self.value_optimizer.zero_grad()
69
        value_loss.backward()
70
        self.value_optimizer.step()
71

72
        # 清空缓存
73
        self.log_probs = []
74
        self.rewards = []
75
        self.states = []
76
        self.values = []
77

78
        return policy_loss.item(), value_loss.item()
79

80
# 训练函数
81
def train_with_baseline(env_name='CartPole-v1', n_episodes=1000):
82
    env = gym.make(env_name)
83
    state_dim = env.observation_space.shape[0]
84
    action_dim = env.action_space.n
85

86
    agent = REINFORCEWithBaseline(state_dim, action_dim)
87

88
    episode_rewards = []
89

90
    for episode in range(n_episodes):
91
        state, _ = env.reset()
92
        episode_reward = 0
93

94
        for step in range(500):
95
            action = agent.select_action(state)
96
            next_state, reward, terminated, truncated, _ = env.step(action)
97
            done = terminated or truncated
98

99
            agent.rewards.append(reward)
100
            episode_reward += reward
101

102
            state = next_state
103

104
            if done:
105
                break
106

107
        policy_loss, value_loss = agent.update()
108
        episode_rewards.append(episode_reward)
109

110
        if (episode + 1) % 100 == 0:
111
            avg_reward = np.mean(episode_rewards[-100:])
112
            print(f"Episode {episode+1}, Avg Reward: {avg_reward:.2f}")
113

114
    env.close()
115
    return episode_rewards, agent
116

117
# 训练对比
118
rewards_baseline, agent_baseline = train_with_baseline()

3.4 优势函数（Advantage Function）#

定义：

A^\pi(s, a) = Q^\pi(s, a) - V^\pi(s)

直观理解：

$A(s,a) > 0$ ：动作 $a$ 比平均水平好，增加概率
$A(s,a) < 0$ ：动作 $a$ 比平均水平差，减少概率

使用优势函数的梯度：

\nabla_\theta J(\theta) = E \left[ \sum_t \nabla_\theta \log \pi_\theta(a_t|s_t) \cdot A^\pi(s_t, a_t) \right]

3.5 广义优势估计（GAE）#

问题：如何估计优势函数？

TD 误差：

\delta_t = r_t + \gamma V(s_{t+1}) - V(s_t)

GAE 定义（Schulman et al., 2015）：

A_t^{\text{GAE}(\gamma, \lambda)} = \sum_{l=0}^\infty (\gamma \lambda)^l \delta_{t+l}

参数：

$\gamma$ ：折扣因子
$\lambda \in [0, 1]$ $λ \in [0, 1]$ ：偏差-方差权衡
- $\lambda = 0$ ：低方差，高偏差（TD）
- $\lambda = 1$ ：高方差，无偏差（Monte Carlo）

递归计算：

A_t = \delta_t + \gamma \lambda A_{t+1}

4. 连续动作空间的策略梯度#

4.1 高斯策略（Gaussian Policy）#

离散动作：使用 Categorical 分布 连续动作：使用高斯分布

\pi_\theta(a|s) = \mathcal{N}(a; \mu_\theta(s), \sigma_\theta(s))

对数概率：

\log \pi_\theta(a|s) = -\frac{1}{2} \left( \frac{(a - \mu_\theta(s))^2}{\sigma_\theta(s)^2} + \log(2\pi\sigma_\theta(s)^2) \right)

4.2 连续动作空间实现（Pendulum-v1）#

1
from torch.distributions import Normal
2

3
class ContinuousPolicyNetwork(nn.Module):
4
    def __init__(self, state_dim, hidden_dim, action_dim):
5
        super(ContinuousPolicyNetwork, self).__init__()
6

7
        self.shared = nn.Sequential(
8
            nn.Linear(state_dim, hidden_dim),
9
            nn.Tanh(),
10
            nn.Linear(hidden_dim, hidden_dim),
11
            nn.Tanh()
12
        )
13

14
        # 均值头
15
        self.mean_head = nn.Linear(hidden_dim, action_dim)
16

17
        # 标准差头（使用 log std 确保正数）
18
        self.log_std_head = nn.Linear(hidden_dim, action_dim)
19

20
    def forward(self, x):
21
        features = self.shared(x)
22
        mean = self.mean_head(features)
23
        log_std = self.log_std_head(features)
24
        std = torch.exp(log_std.clamp(-20, 2))  # 防止数值不稳定
25

26
        return mean, std
27

28
class ContinuousREINFORCE:
29
    def __init__(self, state_dim, action_dim, hidden_dim=128, lr=3e-4, gamma=0.99):
30
        self.gamma = gamma
31
        self.policy = ContinuousPolicyNetwork(state_dim, hidden_dim, action_dim)
32
        self.optimizer = optim.Adam(self.policy.parameters(), lr=lr)
33

34
        self.log_probs = []
35
        self.rewards = []
36

37
    def select_action(self, state):
38
        """从高斯策略采样动作"""
39
        state = torch.FloatTensor(state).unsqueeze(0)
40
        mean, std = self.policy(state)
41

42
        dist = Normal(mean, std)
43
        action = dist.sample()
44

45
        self.log_probs.append(dist.log_prob(action).sum(dim=-1))  # 多维动作求和
46

47
        return action.detach().numpy().flatten()
48

49
    def update(self):
50
        """更新策略"""
51
        returns = []
52
        R = 0
53
        for r in reversed(self.rewards):
54
            R = r + self.gamma * R
55
            returns.insert(0, R)
56

57
        returns = torch.tensor(returns)
58
        returns = (returns - returns.mean()) / (returns.std() + 1e-8)
59

60
        policy_loss = []
61
        for log_prob, R in zip(self.log_probs, returns):
62
            policy_loss.append(-log_prob * R)
63

64
        self.optimizer.zero_grad()
65
        policy_loss = torch.stack(policy_loss).sum()
66
        policy_loss.backward()
67
        self.optimizer.step()
68

69
        self.log_probs = []
70
        self.rewards = []
71

72
        return policy_loss.item()
73

74
# 训练 Pendulum
75
def train_pendulum(n_episodes=500):
76
    env = gym.make('Pendulum-v1')
77
    state_dim = env.observation_space.shape[0]
78
    action_dim = env.action_space.shape[0]
79

80
    agent = ContinuousREINFORCE(state_dim, action_dim)
81

82
    episode_rewards = []
83

84
    for episode in range(n_episodes):
85
        state, _ = env.reset()
86
        episode_reward = 0
87

88
        for step in range(200):
89
            action = agent.select_action(state)
90
            next_state, reward, terminated, truncated, _ = env.step(action)
91
            done = terminated or truncated
92

93
            agent.rewards.append(reward)
94
            episode_reward += reward
95

96
            state = next_state
97

98
            if done:
99
                break
100

101
        loss = agent.update()
102
        episode_rewards.append(episode_reward)
103

104
        if (episode + 1) % 50 == 0:
105
            avg_reward = np.mean(episode_rewards[-50:])
106
            print(f"Episode {episode+1}, Avg Reward: {avg_reward:.2f}")
107

108
    env.close()
109
    return episode_rewards, agent
110

111
rewards_pendulum, agent_pendulum = train_pendulum()
112

113
# 可视化
114
plt.figure(figsize=(10, 5))
115
plt.plot(rewards_pendulum, alpha=0.3)
116
plt.plot(np.convolve(rewards_pendulum, np.ones(50)/50, mode='valid'), linewidth=2)
117
plt.xlabel('Episode')
118
plt.ylabel('Total Reward')
119
plt.title('REINFORCE on Pendulum-v1 (Continuous Actions)')
120
plt.grid(True, alpha=0.3)
121
plt.show()

5. 实战技巧与调参建议#

5.1 学习率调整#

1
from torch.optim.lr_scheduler import StepLR
2

3
# 使用学习率衰减
4
optimizer = optim.Adam(policy.parameters(), lr=1e-3)
5
scheduler = StepLR(optimizer, step_size=200, gamma=0.9)
6

7
# 在训练循环中
8
for episode in range(n_episodes):
9
    # ... 训练代码 ...
10
    scheduler.step()

5.2 梯度裁剪#

1
# 防止梯度爆炸
2
torch.nn.utils.clip_grad_norm_(policy.parameters(), max_norm=0.5)

5.3 熵正则化（Entropy Regularization）#

目的：鼓励探索，防止策略过早收敛到次优解。

J_{\text{total}}(\theta) = J(\theta) + \beta \cdot H(\pi_\theta)

其中 $H(\pi_\theta) = -E_{s,a} [\log \pi_\theta(a|s)]$ 是策略熵。

实现：

1
# 在计算损失时添加熵项
2
entropy = dist.entropy().mean()
3
policy_loss = -(log_probs * advantages).mean() - 0.01 * entropy  # β = 0.01

5.4 超参数推荐#

参数	CartPole	Pendulum	MuJoCo
Learning Rate	1e-3	3e-4	3e-4
Hidden Dim	128	256	256
Gamma	0.99	0.99	0.99
Entropy Coef	0.0	0.01	0.01
Batch Size	1 episode	1 episode	2048 steps

6. REINFORCE 的优缺点与改进方向#

6.1 优点#

✅ 理论简单：直接实现策略梯度定理
✅ 无偏估计：Monte Carlo 回报是无偏的
✅ 适用范围广：离散/连续、确定性/随机策略
✅ 易于实现：代码简洁，适合入门

6.2 缺点#

❌ 高方差：需要大量样本才能稳定学习
❌ 样本效率低：每条轨迹只用一次（on-policy）
❌ 学习速度慢：相比 Actor-Critic 方法
❌ 对超参数敏感：学习率、baseline 选择影响大

6.3 改进方向#

Actor-Critic 方法：
- 使用值函数作为 baseline 和 critic
- 代表算法：A2C、A3C、PPO、SAC
自然策略梯度（NPG）：
- 使用 Fisher 信息矩阵
- 更稳定的更新方向
Trust Region 方法：
- 限制策略更新幅度
- 代表算法：TRPO、PPO
Off-Policy 方法：
- 重用历史数据
- 代表算法：DPG、DDPG、TD3

7. 总结#

7.1 核心要点回顾#

策略梯度定理：
$\nabla_\theta J(\theta) = E \left[ \sum_t \nabla_\theta \log \pi_\theta(a_t|s_t) \cdot R_t \right]$
REINFORCE 算法：
- Monte Carlo 采样估计梯度
- 无偏但高方差
方差降低：
- Baseline 技术（值函数）
- 优势函数 $A(s,a) = Q(s,a) - V(s)$
- GAE（λ 参数权衡偏差-方差）
连续动作：
- 高斯策略 $\pi_\theta(a|s) = \mathcal{N}(\mu_\theta(s), \sigma_\theta(s))$
- 可学习的均值和标准差

7.2 与值函数方法的对比#

维度	策略梯度	Q-learning/DQN
优化目标	直接优化策略	优化值函数
动作空间	离散+连续	主要离散
探索策略	随机策略天然探索	需要 ε-greedy
收敛性	理论保证好	可能震荡
样本效率	低（on-policy）	高（off-policy）
实现难度	中等	较简单

7.3 实践建议#

🎯 入门项目：从 CartPole 开始
🎯 调试技巧：监控策略熵、梯度范数、回报方差
🎯 超参数：先用推荐值，再逐步调优
🎯 进阶学习：深入学习 A2C/PPO，理解 Actor-Critic 框架

参考资源#

经典论文：
- Williams (1992): Simple Statistical Gradient-Following Algorithms
- Sutton et al. (1999): Policy Gradient Methods for RL
- Schulman et al. (2015): High-Dimensional Continuous Control Using GAE
开源实现：
- OpenAI Spinning Up
- Stable Baselines3
推荐课程：
- David Silver 强化学习课程 Lecture 7
- CS 285: Deep RL (UC Berkeley)

策略梯度方法是现代深度强化学习的基石。掌握 REINFORCE 及其变体，不仅能解决实际问题，更能为理解 PPO、SAC 等先进算法打下坚实基础。记住：强化学习是实践的艺术，多动手、多实验，才能真正融会贯通！