1. 演员与评论家 (Actor and Critic)

在第9章中，我们学习了 Policy Gradient (如 REINFORCE)。它虽然能处理连续动作，但方差极大，因为它用整条 Episode 的回报来评估一个动作的好坏。
在第7章中，我们学习了 TD Learning (如 Q-learning)。它方差小（单步更新），但很难处理连续动作。

Actor-Critic (AC) 结合了这两者的优点：

  1. Actor (策略网络)：。负责选动作，像个演员。
  2. Critic (价值网络)：或。负责给动作打分，像个评论家。

核心逻辑：
Actor 不再盲目等待环境的随机回报，而是听从 Critic 的评价。Critic 说这个动作好（TD Error > 0），Actor 就增加概率；Critic 说不好，就减少概率。

2. 优势函数 (Advantage Function)

REINFORCE 的更新公式：

Actor-Critic 的更新公式：

为了进一步降低方差，我们引入 Advantage Function。
即：动作的价值，相对于当前状态平均价值的优势。


这里我们用 TD Error来近似 Advantage。这样我们只需要一个网络估计即可。这就是 A2C (Advantage Actor-Critic)。

3. A2C 算法架构

A2C 通常共享神经网络的前几层（特征提取层），然后分叉出两个头：

  1. Policy Head: 输出动作概率分布（Softmax）。
  2. Value Head: 输出状态价值（Scalar）。

损失函数:

  • Actor Loss:(最大化 Advantage)。
  • Critic Loss:(最小化 TD Error)。
  • Entropy Loss:(可选，鼓励探索，防止过早收敛)。

4. PyTorch 代码实战：A2C

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
import torch
import torch.nn as nn
import torch.optim as optim
from torch.distributions import Categorical

class ActorCritic(nn.Module):
    def __init__(self, state_dim, action_dim):
        super(ActorCritic, self).__init__()
        # 共享特征层
        self.affine = nn.Linear(state_dim, 128)
        
        # Actor Head
        self.action_layer = nn.Linear(128, action_dim)
        
        # Critic Head
        self.value_layer = nn.Linear(128, 1)
        
    def forward(self, x):
        x = torch.relu(self.affine(x))
        
        # Actor 输出概率
        action_probs = torch.softmax(self.action_layer(x), dim=-1)
        
        # Critic 输出 Value
        state_value = self.value_layer(x)
        
        return action_probs, state_value

def train_a2c(env, model, optimizer, gamma=0.99):
    state = env.reset()
    log_probs = []
    values = []
    rewards = []
    
    # 1. 收集轨迹 (这里简化为单步更新或短轨迹)
    # ... (省略循环，假设收集了一段数据) ...
    # 假设 action_probs, state_value = model(state)
    
    # 2. 计算 Returns 和 Advantages
    R = 0
    returns = []
    for r in rewards[::-1]:
        R = r + gamma * R
        returns.insert(0, R)
    returns = torch.tensor(returns)
    
    # 3. 计算 Loss
    # Advantage = Return - Value
    # 注意：这里 detach() 很重要，Critic 的目标是逼近 Return，而不是让 Return 迁就 Value
    advantages = returns - torch.stack(values).detach()
    
    actor_loss = -(torch.stack(log_probs) * advantages).mean()
    critic_loss = nn.MSELoss()(torch.stack(values), returns.unsqueeze(1))
    
    loss = actor_loss + 0.5 * critic_loss
    
    # 4. 更新
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

5. 进阶：从 A2C 到 PPO

A2C 是现代 Policy-based 方法的基石。但它有个缺点：步长难调。

  • 步长太大：策略更新过猛，导致性能崩塌（Policy Collapse）。
  • 步长太小：训练太慢。

PPO (Proximal Policy Optimization) 通过限制策略更新的幅度（Clip 操作），保证了每次更新都在一个“信任区域”内，是目前最流行的 Deep RL 算法（OpenAI 默认算法）。

6. 全系列总结

恭喜你！你已经走完了《强化学习数学原理》的全部旅程：

  1. MDP: 一切的起点，定义了状态、动作、奖励。
  2. Bellman Eq: 评估策略好坏的标尺。
  3. VI/PI: 有模型时的上帝视角解法。
  4. MC: 无模型，从经验中学习（采样）。
  5. TD (Sarsa/Q-learning): 边走边学，结合了 DP 和 MC。
  6. Function Approx (DQN): 征服无限状态空间。
  7. Policy Gradient: 征服连续动作空间。
  8. Actor-Critic: 集大成者，迈向现代 RL。

强化学习的数学大厦已经建成。接下来，就是去实践，去解决真正的问题！

上一章：第9章 - 策略梯度方法 | [返回首页](/)