您现在的位置是：首页 > 技术教程正文

【深度强化学习】(4) Actor-Critic 模型解析，附Pytorch完整代码

admin 阅读： 2024-03-23

后台-插件-广告管理-内容页头部广告（手机）

大家好，今天和各位分享一下深度强化学习中的 Actor-Critic 演员评论家算法，Actor-Critic 算法是一种综合了策略迭代和价值迭代的集成算法。我将使用该模型结合 OpenAI 中的 Gym 环境完成一个小游戏，完整代码可以从我的 GitHub 中获得：

https://github.com/LiSir-HIT/Reinforcement-Learning/tree/main/Model

1. 算法原理

根据 agent 选择动作方法的不同，可以把强化学习方法分为三大类：行动者方法(Actor-only)，评论家方法(Critic-only)，行动者评论家方法(Actor-critic)。

行动者方法中不会对值函数进行估计，直接按照当前策略和环境进行交互。通过交互后得到的立即奖赏值直接优化当前策略。例如：Policy Gradients

评论家方法没有需要维护的策略，评论家方法的策略是直接通过当前的值函数获得的，并通过值函数获得的策略与环境交互。交互得到的立即奖赏值用来优化当前值函数。例如：DQN

行动者评论家方法是由行动者和评论家两个部分构成。行动者用于选择动作，评论家评论选择动作的好坏。行动者选择动作的方法不是依据当前的值函数，而是依据存储的策略。评论家的评论一般采用时间差分误差的形式，时间差分误差是根据当前的值函数计算获得的。时间差分误差是是评论家的唯一输出，并且驱动了行动者和评论家之间的所有学习。

2. 公式推导

根据策略梯度算法的定义，策略优化目标函数如下：

$L_\pi = \sum _{a\in A} log \pi_ \theta (s_t, a_t) (G_{t}^{n}-V(s_t))$

3. 代码实现

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，动作评估输出 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()

4. 案例演示

我们使用 OpenAI 的 gym 库中的环境，完成一个小案例。我们的目的是左右移动黑色小车使得黄色的杆子保持竖直。状态 state 的维度为 4，动作 action 有 2 个。

环境交互与训练部分的代码如下：

import numpy as np
import matplotlib.pyplot as plt
import gym
import torch
from RL_brain 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()

绘制每回合的回报 return

标签:

声明

1.本站遵循行业规范，任何转载的稿件都会明确标注作者和来源；2.本站的原创文章，请转载时务必注明文章作者和来源，不尊重原创的行为我们将追究责任；3.作者投稿可能会经我们编辑修改或补充。

在线投稿：投稿站长QQ：1888636

后台-插件-广告管理-内容页尾部广告（手机）