强化学习：演员评论家 Actor-Critic 算法

局限性：

1. 高方差：直接使用环境反馈（奖励）计算梯度会导致策略梯度的方差很高，影响优化效率；
2. 低效率：由于奖励信号传递较慢，可能需要大量采样才能学到有效的策略。

为了解决这些问题，研究者引入了Critic，用于降低方差并加速策略优化。

3. Actor-Critic 的提出

3.1 概念来源

Actor-Critic 算法由策略梯度和值函数估计结合而成：

• Actor（行动者）：策略网络，决定在每个状态下采取的动作；
• Critic（评论者）：值函数网络，估算当前状态或状态 - 动作对的价值，用于指导 Actor 改进。

这一框架的核心思想是利用 Critic 降低策略梯度的方差，同时保留策略方法的灵活性。

3.2 数学依据

Critic 通过估算值函数 $V^\pi(s)$ 或 $Q^\pi(s, a)$ 来计算时间差分（TD）误差：

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

• Critic 最小化 TD 误差的平方，学习状态值函数；
• Actor 利用 TD 误差调整策略，使得策略向更优的方向发展。

这一机制使 Actor-Critic 算法既可以高效地采样环境反馈，又能够快速调整策略参数。

4. 历史发展与应用

4.1 最早提出

Actor-Critic 算法最早由 Sutton 等人提出（1980 年代），作为策略梯度方法的变体，用于解决高方差问题。

4.2 演化与扩展

1. A3C（Asynchronous Advantage Actor-Critic）：
   • 提出时间：2016 年，由 DeepMind 引入。
   • 关键点：通过多线程并行化显著提升学习效率。
2. PPO（Proximal Policy Optimization）：
   • 提出时间：2017 年，由 OpenAI 提出。
   • 关键点：限制策略更新的幅度，改进稳定性。

Actor-Critic 算法流程的推导

Actor-Critic 算法结合了策略梯度方法（Policy Gradient）和值函数估计，核心是通过 Actor（策略函数）选择动作，通过 Critic（值函数）评估这些动作，并相互协作改进。以下是基于数学公式推导的算法流程。

1. 强化学习的优化目标

目标是最大化累积折扣奖励的期望：

$$J(\theta) = \mathbb{E}{\pi\theta} \left[ \sum_{t=0}^\infty \gamma^t r_t \right]$$

其中：

• $V^\pi(s)$：状态值函数
• $\gamma$：折扣因子，控制未来奖励的权重。
• $r_t$：时间 t 的即时奖励；
• $\pi_\theta(a|s)$：策略函数，表示在状态 s 下选择动作 a 的概率；

2. 策略梯度定理

为了优化策略函数 $\pi_\theta$，我们计算目标函数 $J(\theta)$ 对参数 $\theta$ 的梯度：

$$\nabla_\theta J(\theta) = \mathbb{E}{\pi\theta} \left[ \nabla_\theta \log \pi_\theta(a|s) \cdot A^\pi(s, a) \right]$$

• $A^\pi(s, a)$：优势函数，衡量动作 a 的相对优势。
• $\nabla_\theta \log \pi_\theta(a|s)$：策略的对数梯度，指示如何调整策略参数以提升选取当前动作的概率；

优势函数的估计：

$$A^\pi(s, a) \approx r + \gamma V^\pi(s') - V^\pi(s)$$

其中：

• $s'$：动作 a 执行后的下一状态。
• $V^\pi(s)$：状态值函数，表示在状态 s 时累积奖励的期望；

3. Critic：值函数估计

Critic 的目标是通过最小化均方误差，学习状态值函数 $V^\pi(s)$：

$$L(w) = \frac{1}{2} \mathbb{E} \left[ \left( r + \gamma V^\pi(s') - V^\pi(s) \right)^2 \right]$$

$V^\pi(s)$ 通常由神经网络近似。

参数 $w$ 是 Critic 网络的权重； Critic 的梯度更新公式：

$$\nabla_w L(w) = \left( r + \gamma V^\pi(s') - V^\pi(s) \right) \nabla_w V^\pi(s)$$

4. Actor：策略优化

Actor 根据 Critic 的反馈来优化策略参数 $\theta$。更新公式为：

$$\theta \leftarrow \theta + \alpha \cdot \nabla_\theta \log \pi_\theta(a|s) \cdot \delta$$

其中：

• $\alpha$：学习率。
• $\delta = r + \gamma V^\pi(s') - V^\pi(s)$：时间差分（TD）误差，衡量当前状态值预测的偏差；

Actor 的更新方向由 Critic 计算的 TD 误差指导。

5. 完整算法流程

结合上述部分，Actor-Critic 的算法流程如下：

1. 重复以下步骤直到收敛：
   • 初始化 Actor 和 Critic 网络的参数 $\theta, w$；
   • 在状态 s 下，Actor 根据 $\pi_\theta(a|s)$ 采样动作 a；
   • 执行动作 a，获得奖励 r 和下一状态 s'；
   • Critic 计算 TD 误差：$\delta = r + \gamma V^\pi(s') - V^\pi(s)$；
   • Actor 更新：$\theta \leftarrow \theta + \alpha \cdot \nabla_\theta \log \pi_\theta(a|s) \cdot \delta$；
   • Critic 更新：$w \leftarrow w + \beta \cdot \delta \cdot \nabla_w V^\pi(s)$；

[Python] Actor-Critic 算法实现

算法伪代码

结合上述公式，以下是 Actor-Critic 的简化伪代码：

# 初始化 Actor 和 Critic 的参数
theta = 初始化 Actor 参数
w = 初始化 Critic 参数
for episode in range(最大迭代次数):
    初始化环境
    s = 初始状态
    while not done:
        # Actor 选择动作
        a = 从π_theta(s)中采样动作
        # 执行动作并获得奖励和下一状态
        s_next, r, done = 环境.step(a)
        # Critic 评估当前状态
        V_s = Critic 网络预测值 (s, w)
        V_s_next = Critic 网络预测值 (s_next, w)
        # 计算 TD 误差
        delta = r + gamma * V_s_next - V_s
        # 更新 Critic 参数
        w = w + alpha_critic * delta * ∇_w V_s
        # 更新 Actor 参数
        theta = theta + alpha_actor * delta * ∇_theta log π_theta(a | s)
        # 更新状态
        s = s_next

算法示例代码

以下是使用 PyTorch 实现的 Actor-Critic 算法的示例代码：

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim

# Actor 网络
class Actor(nn.Module):
    def __init__(self, state_dim, action_dim):
        super(Actor, self).__init__()
        self.fc = nn.Sequential(
            nn.Linear(state_dim, 128),
            nn.ReLU(),
            nn.Linear(128, action_dim),
            nn.Softmax(dim=-1)
        )
    
    def forward(self, state):
        return self.fc(state)

# Critic 网络
class Critic(nn.Module):
    def __init__(self, state_dim):
        super(Critic, self).__init__()
        self.fc = nn.Sequential(
            nn.Linear(state_dim, 128),
            nn.ReLU(),
            nn.Linear(128, 1)
        )
    
    def forward(self, state):
        return self.fc(state)

# Actor-Critic 算法
class ActorCritic:
    def __init__(self, state_dim, action_dim, gamma=0.99, lr=1e-3):
        self.actor = Actor(state_dim, action_dim)
        self.critic = Critic(state_dim)
        self.gamma = gamma
        self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=lr)
        self.critic_optimizer = optim.Adam(self.critic.parameters(), lr=lr)
    
    def select_action(self, state):
        state = torch.tensor(state, dtype=torch.float32)
        probs = self.actor(state)
        action = torch.multinomial(probs, 1).item()
        return action, probs[action]
    
    def update(self, state, action_prob, reward, next_state, done):
        state = torch.tensor(state, dtype=torch.float32)
        next_state = torch.tensor(next_state, dtype=torch.float32)
        reward = torch.tensor(reward, dtype=torch.float32)
        done = torch.tensor(done, dtype=torch.float32)
        
        # Critic 更新
        value = self.critic(state)
        next_value = self.critic(next_state)
        target = reward + self.gamma * next_value * (1 - done)
        td_error = target - value
        critic_loss = td_error.pow(2)
        self.critic_optimizer.zero_grad()
        critic_loss.backward()
        self.critic_optimizer.step()
        
        # Actor 更新
        actor_loss = -torch.log(action_prob) * td_error.detach()
        self.actor_optimizer.zero_grad()
        actor_loss.backward()
        self.actor_optimizer.step()

Actor-Critic 算法实战代码

下面是基于 Python 和 PyTorch 的 Actor-Critic 算法的项目实代码：

Actor-->Policy 网络

"""《Actor-Critic 算法》"""
import torch
from torch import nn
from torch.nn import functional as F
import numpy as np

# ------------------------------------#
# 策略梯度 Actor，动作选择
# ------------------------------------#
class PolicyNet(nn.Module):
    def __init__(self, n_states, n_hiddens, n_actions):
        super(PolicyNet, self).__init__()
        self.fc1 = nn.Linear(n_states, n_hiddens)
        self.fc2 = nn.Linear(n_hiddens, n_actions)
        # 前向传播
    def forward(self, x):
        x = self.fc1(x) # [b,n_states]-->[b,n_hiddens]
        x = F.relu(x)
        x = self.fc2(x) # [b,n_hiddens]-->[b,n_actions]
        # 每个状态对应的动作的概率
        x = F.softmax(x, dim=1) # [b,n_actions]-->[b,n_actions]
        return x

Critic-->Value 网络

# ------------------------------------#
# 值函数 Critic，动作评估输出 shape=[b,1]
# ------------------------------------#
class ValueNet(nn.Module):
    def __init__(self, n_states, n_hiddens):
        super(ValueNet, self).__init__()
        self.fc1 = nn.Linear(n_states, n_hiddens)
        self.fc2 = nn.Linear(n_hiddens, 1)
        # 前向传播
    def forward(self, x):
        x = self.fc1(x) # [b,n_states]-->[b,n_hiddens]
        x = F.relu(x)
        x = self.fc2(x) # [b,n_hiddens]-->[b,1]
        return x

Actor-Critic 算法

# ------------------------------------#
# Actor-Critic
# ------------------------------------#
class ActorCritic:
    def __init__(self, n_states, n_hiddens, n_actions, actor_lr, critic_lr, gamma):
        # 属性分配
        self.gamma = gamma
        # 实例化策略网络
        self.actor = PolicyNet(n_states, n_hiddens, n_actions)
        # 实例化价值网络
        self.critic = ValueNet(n_states, n_hiddens)
        # 策略网络的优化器
        self.actor_optimizer = torch.optim.Adam(self.actor.parameters(), lr=actor_lr)
        # 价值网络的优化器
        self.critic_optimizer = torch.optim.Adam(self.critic.parameters(), lr=critic_lr)
        
        # 动作选择
    def take_action(self, state):
        # 维度变换numpy[n_states]-->[1,n_sates]-->tensor
        state = torch.tensor(state[np.newaxis, :])
        # 动作价值函数，当前状态下各个动作的概率
        probs = self.actor(state)
        # 创建以 probs 为标准类型的数据分布
        action_dist = torch.distributions.Categorical(probs)
        # 随机选择一个动作 tensor-->int
        action = action_dist.sample().item()
        return action
    
        # 模型更新
    def update(self, transition_dict):
        # 训练集
        states = torch.tensor(transition_dict['states'], dtype=torch.float)
        actions = torch.tensor(transition_dict['actions']).view(-1,1)
        rewards = torch.tensor(transition_dict['rewards'], dtype=torch.float).view(-1,1)
        next_states = torch.tensor(transition_dict['next_states'], dtype=torch.float)
        dones = torch.tensor(transition_dict['dones'], dtype=torch.float).view(-1,1)
        
        # 预测的当前时刻的 state_value
        td_value = self.critic(states)
        # 目标的当前时刻的 state_value
        td_target = rewards + self.gamma * self.critic(next_states) * (1-dones)
        # 时序差分的误差计算，目标的 state_value 与预测的 state_value 之差
        td_delta = td_target - td_value
        
        # 对每个状态对应的动作价值用 log 函数
        log_probs = torch.log(self.actor(states).gather(1, actions))
        # 策略梯度损失
        actor_loss = torch.mean(-log_probs * td_delta.detach())
        # 值函数损失，预测值和目标值之间
        critic_loss = torch.mean(F.mse_loss(self.critic(states), td_target.detach()))
        
        # 优化器梯度清 0
        self.actor_optimizer.zero_grad()
        # 策略梯度网络的优化器
        self.critic_optimizer.zero_grad()
        # 价值网络的优化器
        
        # 反向传播
        actor_loss.backward()
        critic_loss.backward()
        
        # 参数更新
        self.actor_optimizer.step()
        self.critic_optimizer.step()

算法测试代码

有一个简单的 CartPole 环境，以下是训练代码：

import numpy as np
import matplotlib.pyplot as plt
import gym
import torch
from Actor_Critic import ActorCritic

# -----------------------------------------#
# 参数设置
# -----------------------------------------#
num_episodes = 100 # 总迭代次数
gamma = 0.9 # 折扣因子
actor_lr = 1e-3 # 策略网络的学习率
critic_lr = 1e-2 # 价值网络的学习率
n_hiddens = 16 # 隐含层神经元个数
env_name = 'CartPole-v1'
return_list = [] # 保存每个回合的 return

# -----------------------------------------#
# 环境加载
# -----------------------------------------#
env = gym.make(env_name, render_mode="human")
n_states = env.observation_space.shape[0] # 状态数 4
n_actions = env.action_space.n # 动作数 2

# -----------------------------------------#
# 模型构建
# -----------------------------------------#
agent = ActorCritic(n_states=n_states, # 状态数
                    n_hiddens=n_hiddens, # 隐含层数
                    n_actions=n_actions, # 动作数
                    actor_lr=actor_lr, # 策略网络学习率
                    critic_lr=critic_lr, # 价值网络学习率
                    gamma=gamma) # 折扣因子

# -----------------------------------------#
# 训练--回合更新
# -----------------------------------------#
for i in range(num_episodes):
    state = env.reset()[0] # 环境重置
    done = False # 任务完成的标记
    episode_return = 0 # 累计每回合的 reward
    # 构造数据集，保存每个回合的状态数据
    transition_dict = {
        'states': [],
        'actions': [],
        'next_states': [],
        'rewards': [],
        'dones': [],
    }
    while not done:
        action = agent.take_action(state) # 动作选择
        next_state, reward, done, _, _ = env.step(action) # 环境更新
        # 保存每个时刻的状态\动作\...
        transition_dict['states'].append(state)
        transition_dict['actions'].append(action)
        transition_dict['next_states'].append(next_state)
        transition_dict['rewards'].append(reward)
        transition_dict['dones'].append(done)
        # 更新状态
        state = next_state
        # 累计回合奖励
        episode_return += reward
    # 保存每个回合的 return
    return_list.append(episode_return)
    # 模型训练
    agent.update(transition_dict)
    # 打印回合信息
    print(f'iter:{i}, return:{np.mean(return_list[-10:])}')

# --------------------------------------#
# 绘图
# --------------------------------------#
plt.plot(return_list)
plt.title('return')
plt.show()

[Notice] 关键点总结

1. Critic 的稳定性：Critic 的误差直接影响 Actor 的梯度更新。
2. 熵正则化：为了鼓励探索，可以对 Actor 的损失函数加入熵项。
3. 多线程优化：使用 A3C（Asynchronous Advantage Actor-Critic）可以提升性能。
4. PPO 改进：限制更新范围，解决策略更新过程中的不稳定性。

环境配置：Python 3.11.5, torch 2.1.0, torchvision 0.16.0, gym 0.26.2

总结

Actor-Critic 算法的提出源于策略梯度方法的高方差问题，通过结合值函数（Critic）降低优化方差，提高学习效率。随着强化学习的不断发展，Actor-Critic 及其扩展（如 A3C、PPO）成为复杂任务中广泛使用的算法。