PythonAI算法
强化学习：演员评论家 Actor-Critic 算法
Actor-Critic 算法结合策略梯度与值函数估计。Actor 负责动作选择，Critic 评估价值并降低方差。通过 TD 误差指导策略更新，解决高方差和收敛慢问题。包含数学推导、伪代码及 PyTorch 实战示例，适用于 CartPole 等环境训练。
Actor-Critic 算法结合策略梯度与值函数估计。Actor 负责动作选择，Critic 评估价值并降低方差。通过 TD 误差指导策略更新，解决高方差和收敛慢问题。包含数学推导、伪代码及 PyTorch 实战示例，适用于 CartPole 等环境训练。
Actor-Critic 算法是一种强化学习中的方法，结合了'演员'（Actor）和'评论家'（Critic）两个部分。下面用一个生活中的比喻来说明它的原理：
想象你是一名学习爬山的机器人，而你的目标是找到山顶（获得最高的奖励）。在爬山过程中：
Actor-Critic 算法的运作过程大致如下：
通过这种合作方式，Actor 不断优化动作策略，而 Critic 不断提升评价的准确性。
这个名字直接反映了两者的分工：
两者的结合比单独使用 Actor 或 Critic 效果更好，因为它们互相弥补了对方的不足。
就像你学习开车，你是 Actor，根据道路选择要踩油门还是刹车，而你的驾驶教练就是Critic，告诉你哪个动作更安全、更接近目标。
Actor-Critic 算法是强化学习领域的一种重要方法，它结合了值函数估计和策略优化的优点。在理解其背景时，需要从强化学习的演化历史、策略梯度方法的局限性以及如何通过值函数辅助优化策略展开。
强化学习的目标是使智能体通过与环境的交互，学会在不同状态下选择最优动作，从而最大化长期收益。主要研究方法可以分为以下几类：
随着强化学习问题复杂度的增加，仅依赖值函数方法会面临高维状态空间下的维度灾难，而纯策略方法在优化过程中可能收敛速度较慢。因此，结合策略与值函数的 Actor-Critic 应运而生。
策略梯度方法通过优化策略函数直接解决强化学习问题，核心思想是通过以下公式更新策略参数：
$$\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)$ 是优势函数，用于衡量动作的相对好坏。
为了解决这些问题，研究者引入了Critic，用于降低方差并加速策略优化。
Actor-Critic 算法由策略梯度和值函数估计结合而成：
这一框架的核心思想是利用 Critic 降低策略梯度的方差，同时保留策略方法的灵活性。
Critic 通过估算值函数 $V^\pi(s)$ 或 $Q^\pi(s, a)$ 来计算时间差分（TD）误差：
$$\delta_t = r_t + \gamma V^\pi(s_{t+1}) - V^\pi(s_t)$$
这一机制使 Actor-Critic 算法既可以高效地采样环境反馈，又能够快速调整策略参数。
Actor-Critic 算法最早由 Sutton 等人提出（1980 年代），作为策略梯度方法的变体，用于解决高方差问题。
Actor-Critic 算法结合了策略梯度方法（Policy Gradient）和值函数估计，核心是通过 Actor（策略函数）选择动作，通过 Critic（值函数）评估这些动作，并相互协作改进。以下是基于数学公式推导的算法流程。
目标是最大化累积折扣奖励的期望：
$$J(\theta) = \mathbb{E}{\pi\theta} \left[ \sum_{t=0}^\infty \gamma^t r_t \right]$$
其中：
为了优化策略函数 $\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) \approx r + \gamma V^\pi(s') - V^\pi(s)$$
其中：
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)$$
Actor 根据 Critic 的反馈来优化策略参数 $\theta$。更新公式为：
$$\theta \leftarrow \theta + \alpha \cdot \nabla_\theta \log \pi_\theta(a|s) \cdot \delta$$
其中：
Actor 的更新方向由 Critic 计算的 TD 误差指导。
结合上述部分，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()
下面是基于 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
# ------------------------------------#
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()
环境配置：Python 3.11.5, torch 2.1.0, torchvision 0.16.0, gym 0.26.2
Actor-Critic 算法的提出源于策略梯度方法的高方差问题，通过结合值函数（Critic）降低优化方差，提高学习效率。随着强化学习的不断发展，Actor-Critic 及其扩展（如 A3C、PPO）成为复杂任务中广泛使用的算法。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
生成新的随机RSA私钥和公钥pem证书。 在线工具，RSA密钥对生成器在线工具，online
基于 Mermaid.js 实时预览流程图、时序图等图表，支持源码编辑与即时渲染。 在线工具，Mermaid 预览与可视化编辑在线工具，online
解析常见 curl 参数并生成 fetch、axios、PHP curl 或 Python requests 示例代码。 在线工具，curl 转代码在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online