Actor-Critic 算法家族

引言#

在上一篇文章中，我们详细介绍了策略梯度方法，特别是 REINFORCE 算法。虽然 REINFORCE 理论优雅，但其高方差问题严重制约了学习效率。Actor-Critic 方法应运而生，成为现代强化学习的主流范式。

Actor-Critic 的核心思想：

Actor（演员）：策略网络 $\pi_\theta(a|s)$ ，负责选择动作
Critic（评论家）：值函数网络 $V_\phi(s)$ 或 $Q_\phi(s,a)$ ，负责评估动作质量

相比 REINFORCE 的优势：

✅ 低方差：使用学到的值函数替代 Monte Carlo 回报
✅ 在线学习：可以在每步更新，不必等到回合结束
✅ Bootstrap：利用时序差分（TD）学习加速收敛

本文将系统介绍 Actor-Critic 家族的核心算法：A2C/A3C、PPO、SAC，并提供完整的代码实现。

1. Actor-Critic 基础框架#

1.1 核心原理#

策略梯度回顾：

\nabla_\theta J(\theta) = E_{\pi_\theta} \left[ \nabla_\theta \log \pi_\theta(a|s) \cdot Q^\pi(s,a) \right]

关键改进：用学到的 Critic $Q_\phi(s,a)$ 或 $V_\phi(s)$ 替代真实 $Q^\pi(s,a)$ 。

优势函数（Advantage）：

A(s,a) = Q(s,a) - V(s)

Actor-Critic 梯度：

\nabla_\theta J(\theta) \approx E \left[ \nabla_\theta \log \pi_\theta(a|s) \cdot A_\phi(s,a) \right]

1.2 算法架构#

1
环境交互循环：
2
1. Actor 根据当前策略 π_θ(a|s) 选择动作 a
3
2. 执行动作，观察奖励 r 和下一状态 s'
4
3. Critic 计算 TD 误差或优势函数
5
4. 使用 TD 误差更新 Critic 参数 φ
6
5. 使用优势函数更新 Actor 参数 θ

1.3 优势函数的估计方法#

方法 1：TD(0) 估计#

A(s,a) = r + \gamma V(s') - V(s) = \delta_t

方法 2：n-step TD#

A(s,a) = \sum_{k=0}^{n-1} \gamma^k r_{t+k} + \gamma^n V(s_{t+n}) - V(s_t)

方法 3：GAE（广义优势估计）#

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

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

2. A2C/A3C：同步与异步优势 Actor-Critic#

2.1 A3C（Asynchronous Advantage Actor-Critic）#

核心创新（Mnih et al., 2016）：

多个 worker 并行采样，异步更新全局网络
无需经验回放（Experience Replay）
CPU 多线程，成本低

算法流程：

1
全局网络：θ_global（Actor）、φ_global（Critic）
2

3
每个 Worker i：
4
  1. 从全局网络复制参数：θ_i ← θ_global, φ_i ← φ_global
5
  2. 采样 n 步轨迹 {s_t, a_t, r_t}
6
  3. 计算 n-step 回报和优势
7
  4. 计算梯度 ∇θ 和 ∇φ
8
  5. 异步更新全局网络（加锁）
9
  6. 重复

2.2 A2C（Advantage Actor-Critic）#

改进：

同步更新：所有 worker 同时采样，集中更新
批量梯度：减少梯度噪声
GPU 友好：批量操作更适合 GPU 加速

A2C vs A3C：

维度	A3C	A2C
更新方式	异步	同步
硬件	CPU 多线程	GPU 批处理
梯度噪声	较大	较小
实现难度	需要线程同步	简单
流行度	历史经典	当前主流

2.3 A2C 完整实现（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
class ActorCriticNetwork(nn.Module):
10
    """共享特征提取的 Actor-Critic 网络"""
11
    def __init__(self, state_dim, action_dim, hidden_dim=128):
12
        super(ActorCriticNetwork, self).__init__()
13

14
        # 共享层
15
        self.shared = nn.Sequential(
16
            nn.Linear(state_dim, hidden_dim),
17
            nn.ReLU(),
18
            nn.Linear(hidden_dim, hidden_dim),
19
            nn.ReLU()
20
        )
21

22
        # Actor 头（策略）
23
        self.actor = nn.Linear(hidden_dim, action_dim)
24

25
        # Critic 头（值函数）
26
        self.critic = nn.Linear(hidden_dim, 1)
27

28
    def forward(self, x):
29
        features = self.shared(x)
30
        action_probs = torch.softmax(self.actor(features), dim=-1)
31
        state_value = self.critic(features)
32
        return action_probs, state_value
33

34
class A2CAgent:
35
    def __init__(self, state_dim, action_dim, lr=1e-3, gamma=0.99,
36
                 value_coef=0.5, entropy_coef=0.01):
37
        self.gamma = gamma
38
        self.value_coef = value_coef
39
        self.entropy_coef = entropy_coef
40

41
        self.network = ActorCriticNetwork(state_dim, action_dim)
42
        self.optimizer = optim.Adam(self.network.parameters(), lr=lr)
43

44
    def select_action(self, state):
45
        """选择动作并返回概率、值"""
46
        state = torch.FloatTensor(state).unsqueeze(0)
47
        with torch.no_grad():
48
            action_probs, state_value = self.network(state)
49

50
        dist = Categorical(action_probs)
51
        action = dist.sample()
52

53
        return action.item(), dist.log_prob(action), state_value.squeeze()
54

55
    def compute_returns(self, rewards, values, dones, last_value):
56
        """计算 n-step returns"""
57
        returns = []
58
        R = last_value
59

60
        for step in reversed(range(len(rewards))):
61
            R = rewards[step] + self.gamma * R * (1 - dones[step])
62
            returns.insert(0, R)
63

64
        return torch.tensor(returns)
65

66
    def update(self, states, actions, log_probs, returns, values):
67
        """更新 Actor-Critic 网络"""
68
        states = torch.FloatTensor(states)
69
        actions = torch.LongTensor(actions)
70
        old_log_probs = torch.stack(log_probs)
71
        returns = returns.detach()
72
        old_values = torch.stack(values)
73

74
        # 前向传播
75
        action_probs, state_values = self.network(states)
76
        dist = Categorical(action_probs)
77

78
        # 计算优势函数
79
        advantages = returns - old_values.detach()
80

81
        # Actor loss（策略梯度）
82
        new_log_probs = dist.log_prob(actions)
83
        actor_loss = -(new_log_probs * advantages).mean()
84

85
        # Critic loss（值函数）
86
        critic_loss = nn.MSELoss()(state_values.squeeze(), returns)
87

88
        # 熵正则化（鼓励探索）
89
        entropy = dist.entropy().mean()
90

91
        # 总损失
92
        loss = actor_loss + self.value_coef * critic_loss - self.entropy_coef * entropy
93

94
        # 反向传播
95
        self.optimizer.zero_grad()
96
        loss.backward()
97
        torch.nn.utils.clip_grad_norm_(self.network.parameters(), max_norm=0.5)
98
        self.optimizer.step()
99

100
        return {
101
            'loss': loss.item(),
102
            'actor_loss': actor_loss.item(),
103
            'critic_loss': critic_loss.item(),
104
            'entropy': entropy.item()
105
        }
106

107
def train_a2c(env_name='CartPole-v1', n_episodes=1000, n_steps=5):
108
    """训练 A2C 智能体"""
109
    env = gym.make(env_name)
110
    state_dim = env.observation_space.shape[0]
111
    action_dim = env.action_space.n
112

113
    agent = A2CAgent(state_dim, action_dim)
114

115
    episode_rewards = []
116
    running_reward = 0
117

118
    state, _ = env.reset()
119

120
    for episode in range(n_episodes):
121
        # 收集 n-step 轨迹
122
        states, actions, rewards, log_probs, values, dones = [], [], [], [], [], []
123

124
        for step in range(n_steps):
125
            action, log_prob, value = agent.select_action(state)
126
            next_state, reward, terminated, truncated, _ = env.step(action)
127
            done = terminated or truncated
128

129
            states.append(state)
130
            actions.append(action)
131
            rewards.append(reward)
132
            log_probs.append(log_prob)
133
            values.append(value)
134
            dones.append(done)
135

136
            state = next_state
137
            running_reward += reward
138

139
            if done:
140
                state, _ = env.reset()
141
                episode_rewards.append(running_reward)
142
                running_reward = 0
143

144
        # 计算最后状态的值（bootstrap）
145
        with torch.no_grad():
146
            _, last_value = agent.network(torch.FloatTensor(state).unsqueeze(0))
147
            last_value = last_value.squeeze()
148

149
        # 计算 returns
150
        returns = agent.compute_returns(rewards, values, dones, last_value)
151

152
        # 更新网络
153
        metrics = agent.update(states, actions, log_probs, returns, values)
154

155
        if (episode + 1) % 100 == 0 and episode_rewards:
156
            avg_reward = np.mean(episode_rewards[-100:])
157
            print(f"Episode {episode+1}, Avg Reward: {avg_reward:.2f}, "
158
                  f"Entropy: {metrics['entropy']:.4f}")
159

160
    env.close()
161
    return episode_rewards, agent
162

163
# 训练
164
rewards_a2c, agent_a2c = train_a2c()
165

166
# 可视化
167
plt.figure(figsize=(10, 5))
168
plt.plot(rewards_a2c, alpha=0.3, label='Raw')
169
plt.plot(np.convolve(rewards_a2c, np.ones(50)/50, mode='valid'), label='Moving Avg')
170
plt.xlabel('Episode')
171
plt.ylabel('Total Reward')
172
plt.title('A2C Training on CartPole-v1')
173
plt.legend()
174
plt.grid(True, alpha=0.3)
175
plt.show()

3. PPO：近端策略优化#

3.1 PPO 的动机#

问题：策略梯度更新步长难以控制

步长太小 → 学习慢
步长太大 → 策略崩溃（performance collapse）

解决方案：限制策略更新的幅度，确保新策略不会偏离旧策略太远。

3.2 重要性采样（Importance Sampling）#

目标：使用旧策略 $\pi_{\theta_{\text{old}}}$ 的数据优化新策略 $\pi_\theta$ 。

重要性权重：

\rho_t(\theta) = \frac{\pi_\theta(a_t|s_t)}{\pi_{\theta_{\text{old}}}(a_t|s_t)}

策略梯度（重要性采样形式）：

\nabla_\theta J(\theta) = E_{\theta_{\text{old}}} \left[ \rho_t(\theta) \nabla_\theta \log \pi_\theta(a_t|s_t) A^{\theta_{\text{old}}}(s_t, a_t) \right]

3.3 PPO-Clip 算法#

目标函数（Schulman et al., 2017）：

L^{\text{CLIP}}(\theta) = E_t \left[ \min \left( \rho_t(\theta) A_t, \text{clip}(\rho_t(\theta), 1-\epsilon, 1+\epsilon) A_t \right) \right]

关键参数： $\epsilon$ （通常取 0.1 或 0.2）

直观解释：

当 $A_t > 0$ $A_{t} > 0$ （好动作）：
- 如果 $\rho_t > 1+\epsilon$ （新策略概率过大），裁剪为 $1+\epsilon$
当 $A_t < 0$ $A_{t} < 0$ （坏动作）：
- 如果 $\rho_t < 1-\epsilon$ （新策略概率过小），裁剪为 $1-\epsilon$

防止过度更新：保守地增加好动作概率、减少坏动作概率。

3.4 PPO 完整实现#

1
class PPOAgent:
2
    def __init__(self, state_dim, action_dim, lr=3e-4, gamma=0.99,
3
                 epsilon=0.2, value_coef=0.5, entropy_coef=0.01,
4
                 n_epochs=10, batch_size=64):
5
        self.gamma = gamma
6
        self.epsilon = epsilon
7
        self.value_coef = value_coef
8
        self.entropy_coef = entropy_coef
9
        self.n_epochs = n_epochs
10
        self.batch_size = batch_size
11

12
        self.network = ActorCriticNetwork(state_dim, action_dim)
13
        self.optimizer = optim.Adam(self.network.parameters(), lr=lr)
14

15
        # 经验缓冲区
16
        self.states = []
17
        self.actions = []
18
        self.log_probs = []
19
        self.rewards = []
20
        self.dones = []
21
        self.values = []
22

23
    def select_action(self, state):
24
        """选择动作"""
25
        state = torch.FloatTensor(state).unsqueeze(0)
26
        with torch.no_grad():
27
            action_probs, state_value = self.network(state)
28

29
        dist = Categorical(action_probs)
30
        action = dist.sample()
31
        log_prob = dist.log_prob(action)
32

33
        return action.item(), log_prob.item(), state_value.item()
34

35
    def store_transition(self, state, action, log_prob, reward, done, value):
36
        """存储经验"""
37
        self.states.append(state)
38
        self.actions.append(action)
39
        self.log_probs.append(log_prob)
40
        self.rewards.append(reward)
41
        self.dones.append(done)
42
        self.values.append(value)
43

44
    def compute_gae(self, next_value):
45
        """计算 GAE"""
46
        advantages = []
47
        gae = 0
48

49
        values = self.values + [next_value]
50

51
        for step in reversed(range(len(self.rewards))):
52
            delta = self.rewards[step] + self.gamma * values[step + 1] * (1 - self.dones[step]) - values[step]
53
            gae = delta + self.gamma * 0.95 * (1 - self.dones[step]) * gae  # λ = 0.95
54
            advantages.insert(0, gae)
55

56
        advantages = torch.tensor(advantages)
57
        returns = advantages + torch.tensor(self.values)
58

59
        # 标准化优势函数
60
        advantages = (advantages - advantages.mean()) / (advantages.std() + 1e-8)
61

62
        return advantages, returns
63

64
    def update(self):
65
        """PPO 更新"""
66
        # 获取下一状态的值（bootstrap）
67
        with torch.no_grad():
68
            if self.dones[-1]:
69
                next_value = 0
70
            else:
71
                _, next_value = self.network(torch.FloatTensor(self.states[-1]).unsqueeze(0))
72
                next_value = next_value.item()
73

74
        # 计算 GAE 和 returns
75
        advantages, returns = self.compute_gae(next_value)
76

77
        # 转换为张量
78
        states = torch.FloatTensor(self.states)
79
        actions = torch.LongTensor(self.actions)
80
        old_log_probs = torch.FloatTensor(self.log_probs)
81

82
        # PPO epochs
83
        for epoch in range(self.n_epochs):
84
            # 随机打乱
85
            indices = torch.randperm(len(states))
86

87
            for start in range(0, len(states), self.batch_size):
88
                end = start + self.batch_size
89
                batch_indices = indices[start:end]
90

91
                batch_states = states[batch_indices]
92
                batch_actions = actions[batch_indices]
93
                batch_old_log_probs = old_log_probs[batch_indices]
94
                batch_advantages = advantages[batch_indices]
95
                batch_returns = returns[batch_indices]
96

97
                # 前向传播
98
                action_probs, state_values = self.network(batch_states)
99
                dist = Categorical(action_probs)
100

101
                # 新的 log 概率
102
                new_log_probs = dist.log_prob(batch_actions)
103

104
                # 重要性权重
105
                ratio = torch.exp(new_log_probs - batch_old_log_probs)
106

107
                # PPO-Clip 目标
108
                surr1 = ratio * batch_advantages
109
                surr2 = torch.clamp(ratio, 1 - self.epsilon, 1 + self.epsilon) * batch_advantages
110
                actor_loss = -torch.min(surr1, surr2).mean()
111

112
                # Critic loss
113
                critic_loss = nn.MSELoss()(state_values.squeeze(), batch_returns)
114

115
                # 熵
116
                entropy = dist.entropy().mean()
117

118
                # 总损失
119
                loss = actor_loss + self.value_coef * critic_loss - self.entropy_coef * entropy
120

121
                # 更新
122
                self.optimizer.zero_grad()
123
                loss.backward()
124
                torch.nn.utils.clip_grad_norm_(self.network.parameters(), max_norm=0.5)
125
                self.optimizer.step()
126

127
        # 清空缓冲区
128
        self.states = []
129
        self.actions = []
130
        self.log_probs = []
131
        self.rewards = []
132
        self.dones = []
133
        self.values = []
134

135
def train_ppo(env_name='CartPole-v1', n_episodes=500, update_every=2048):
136
    """训练 PPO 智能体"""
137
    env = gym.make(env_name)
138
    state_dim = env.observation_space.shape[0]
139
    action_dim = env.action_space.n
140

141
    agent = PPOAgent(state_dim, action_dim)
142

143
    episode_rewards = []
144
    episode_reward = 0
145
    state, _ = env.reset()
146

147
    for step in range(1, n_episodes * 500 + 1):
148
        action, log_prob, value = agent.select_action(state)
149
        next_state, reward, terminated, truncated, _ = env.step(action)
150
        done = terminated or truncated
151

152
        agent.store_transition(state, action, log_prob, reward, done, value)
153
        episode_reward += reward
154

155
        state = next_state
156

157
        if done:
158
            episode_rewards.append(episode_reward)
159
            episode_reward = 0
160
            state, _ = env.reset()
161

162
        # 定期更新
163
        if step % update_every == 0:
164
            agent.update()
165

166
            if episode_rewards:
167
                avg_reward = np.mean(episode_rewards[-100:])
168
                print(f"Step {step}, Episodes: {len(episode_rewards)}, Avg Reward: {avg_reward:.2f}")
169

170
    env.close()
171
    return episode_rewards, agent
172

173
# 训练
174
rewards_ppo, agent_ppo = train_ppo()
175

176
# 可视化对比
177
plt.figure(figsize=(12, 5))
178
plt.plot(rewards_a2c, alpha=0.3, label='A2C')
179
plt.plot(rewards_ppo, alpha=0.3, label='PPO')
180
plt.plot(np.convolve(rewards_a2c, np.ones(50)/50, mode='valid'), label='A2C (smoothed)', linewidth=2)
181
plt.plot(np.convolve(rewards_ppo, np.ones(50)/50, mode='valid'), label='PPO (smoothed)', linewidth=2)
182
plt.xlabel('Episode')
183
plt.ylabel('Total Reward')
184
plt.title('A2C vs PPO on CartPole-v1')
185
plt.legend()
186
plt.grid(True, alpha=0.3)
187
plt.show()

4. SAC：软演员-评论家#

4.1 最大熵强化学习#

传统目标：最大化累积奖励

J(\pi) = E_\pi \left[ \sum_t \gamma^t r_t \right]

最大熵目标（Maximum Entropy RL）：同时最大化奖励和策略熵

J(\pi) = E_\pi \left[ \sum_t \gamma^t (r_t + \alpha H(\pi(\cdot|s_t))) \right]

其中 $H(\pi) = -E[\log \pi(a|s)]$ 是策略熵。

优势：

鼓励探索
提升鲁棒性
自动平衡探索-利用

4.2 SAC 算法（Soft Actor-Critic）#

核心组件（Haarnoja et al., 2018）：

Actor：高斯策略 $\pi_\theta(a|s)$
双 Critic：两个 Q 网络 $Q_{\phi_1}, Q_{\phi_2}$ （减少过估计）
温度参数 $\alpha$ ：自动调节探索强度

目标函数：

Critic 更新：

L_Q(\phi) = E_{(s,a,r,s') \sim \mathcal{D}} \left[ (Q_\phi(s,a) - y)^2 \right]

其中：

y = r + \gamma (Q_{\text{target}}(s', a') - \alpha \log \pi_\theta(a'|s')), \quad a' \sim \pi_\theta(\cdot|s')

Actor 更新：

L_\pi(\theta) = E_{s \sim \mathcal{D}, a \sim \pi_\theta} \left[ \alpha \log \pi_\theta(a|s) - Q_\phi(s,a) \right]

温度参数自动调节：

L_\alpha = E_{a \sim \pi_\theta} \left[ -\alpha (\log \pi_\theta(a|s) + \bar{H}) \right]

其中 $\bar{H}$ 是目标熵（通常设为 $-\dim(\mathcal{A})$ ）。

4.3 SAC 实现要点#

1
class SACActor(nn.Module):
2
    """SAC Actor（高斯策略）"""
3
    def __init__(self, state_dim, action_dim, hidden_dim=256):
4
        super(SACActor, self).__init__()
5

6
        self.net = nn.Sequential(
7
            nn.Linear(state_dim, hidden_dim),
8
            nn.ReLU(),
9
            nn.Linear(hidden_dim, hidden_dim),
10
            nn.ReLU()
11
        )
12

13
        self.mean = nn.Linear(hidden_dim, action_dim)
14
        self.log_std = nn.Linear(hidden_dim, action_dim)
15

16
    def forward(self, state):
17
        x = self.net(state)
18
        mean = self.mean(x)
19
        log_std = self.log_std(x).clamp(-20, 2)
20
        return mean, log_std
21

22
    def sample(self, state):
23
        """采样动作（使用重参数化技巧）"""
24
        mean, log_std = self.forward(state)
25
        std = log_std.exp()
26

27
        # 重参数化
28
        normal = torch.distributions.Normal(mean, std)
29
        x_t = normal.rsample()  # rsample() 支持梯度回传
30

31
        # Tanh 压缩到 [-1, 1]
32
        action = torch.tanh(x_t)
33

34
        # 计算 log 概率（修正 Tanh 变换）
35
        log_prob = normal.log_prob(x_t)
36
        log_prob -= torch.log(1 - action.pow(2) + 1e-6)
37
        log_prob = log_prob.sum(1, keepdim=True)
38

39
        return action, log_prob
40

41
class SACCritic(nn.Module):
42
    """SAC Critic（Q 网络）"""
43
    def __init__(self, state_dim, action_dim, hidden_dim=256):
44
        super(SACCritic, self).__init__()
45

46
        self.q1 = nn.Sequential(
47
            nn.Linear(state_dim + action_dim, hidden_dim),
48
            nn.ReLU(),
49
            nn.Linear(hidden_dim, hidden_dim),
50
            nn.ReLU(),
51
            nn.Linear(hidden_dim, 1)
52
        )
53

54
        self.q2 = nn.Sequential(
55
            nn.Linear(state_dim + action_dim, hidden_dim),
56
            nn.ReLU(),
57
            nn.Linear(hidden_dim, hidden_dim),
58
            nn.ReLU(),
59
            nn.Linear(hidden_dim, 1)
60
        )
61

62
    def forward(self, state, action):
63
        sa = torch.cat([state, action], dim=1)
64
        return self.q1(sa), self.q2(sa)
65

66
# SAC 完整实现略（代码较长，核心思想如上）

5. 算法对比与选择指南#

5.1 性能对比#

算法	样本效率	稳定性	离散动作	连续动作	实现难度
A2C	中	中	✅	✅	简单
A3C	中	中	✅	✅	中等
PPO	中-高	高	✅	✅	中等
SAC	高	高	❌	✅	复杂

5.2 应用场景建议#

选择 A2C/A3C：

简单环境（如 Atari、CartPole）
需要快速原型验证
计算资源有限

选择 PPO：

最推荐的通用算法
需要稳定训练
连续或离散动作空间
OpenAI/DeepMind 工业标准

选择 SAC：

连续控制任务（机器人、自动驾驶）
需要最大样本效率
对探索要求高
有充足计算资源

6. 实战技巧#

6.1 超参数调优#

1
# PPO 推荐参数
2
{
3
    'lr': 3e-4,
4
    'gamma': 0.99,
5
    'epsilon': 0.2,       # clip 范围
6
    'value_coef': 0.5,
7
    'entropy_coef': 0.01,
8
    'n_epochs': 10,       # 每次更新的 epoch 数
9
    'batch_size': 64,
10
    'gae_lambda': 0.95
11
}
12

13
# SAC 推荐参数
14
{
15
    'lr_actor': 3e-4,
16
    'lr_critic': 3e-4,
17
    'lr_alpha': 3e-4,
18
    'gamma': 0.99,
19
    'tau': 0.005,         # 软更新系数
20
    'buffer_size': 1e6,
21
    'batch_size': 256,
22
    'auto_entropy': True  # 自动调节温度
23
}

6.2 调试建议#

1
# 监控关键指标
2
metrics = {
3
    'episode_reward': [],
4
    'actor_loss': [],
5
    'critic_loss': [],
6
    'entropy': [],          # 策略熵（探索程度）
7
    'value_estimate': [],   # 值函数估计
8
    'advantage_mean': [],   # 优势函数均值
9
    'grad_norm': []         # 梯度范数
10
}
11

12
# 可视化学习曲线
13
def plot_training_curves(metrics):
14
    fig, axes = plt.subplots(2, 3, figsize=(15, 8))
15

16
    axes[0, 0].plot(metrics['episode_reward'])
17
    axes[0, 0].set_title('Episode Reward')
18

19
    axes[0, 1].plot(metrics['actor_loss'])
20
    axes[0, 1].set_title('Actor Loss')
21

22
    axes[0, 2].plot(metrics['critic_loss'])
23
    axes[0, 2].set_title('Critic Loss')
24

25
    axes[1, 0].plot(metrics['entropy'])
26
    axes[1, 0].set_title('Policy Entropy')
27

28
    axes[1, 1].plot(metrics['value_estimate'])
29
    axes[1, 1].set_title('Value Estimate')
30

31
    axes[1, 2].plot(metrics['grad_norm'])
32
    axes[1, 2].set_title('Gradient Norm')
33

34
    plt.tight_layout()
35
    plt.show()

7. 总结#

7.1 核心要点回顾#

Actor-Critic 框架：
- Actor 优化策略
- Critic 评估动作
- 低方差、快速学习
A2C/A3C：
- 基础 Actor-Critic
- 并行采样提升效率
PPO：
- Clip 限制策略更新
- 工业界首选
- 稳定且易调
SAC：
- 最大熵框架
- 连续控制最佳
- 样本效率高

7.2 进阶学习路径#

深入 PPO 变体：
- PPO-Penalty
- PPO with LSTM
- Multi-agent PPO
探索其他算法：
- TRPO（Trust Region Policy Optimization）
- TD3（Twin Delayed DDPG）
- DreamerV3（Model-based RL）
实战项目：
- MuJoCo 机器人控制
- Atari 游戏
- 自定义环境

参考资源#

经典论文：
- Mnih et al. (2016): Asynchronous Methods for Deep RL (A3C)
- Schulman et al. (2017): Proximal Policy Optimization Algorithms (PPO)
- Haarnoja et al. (2018): Soft Actor-Critic (SAC)
开源实现：
推荐课程：
- OpenAI Spinning Up in Deep RL
- CS 285: Deep Reinforcement Learning (UC Berkeley)

Actor-Critic 方法将策略优化与值函数学习完美结合，成为现代强化学习的基石。掌握 PPO 和 SAC，你将能够解决大部分实际强化学习问题。记住：调试强化学习需要耐心，多实验、多可视化、多对比！