强化学习基础算法介绍，DQN，策略梯度算法，Actor-Critic算法

蓝天白云大海沙滩Herman

已于 2024-04-05 22:41:23 修改

阅读量967

点赞数 15

文章标签：算法机器学习人工智能 python

于 2024-04-05 21:13:40 首次发布

本文链接：https://blog.csdn.net/weixin_41106546/article/details/137408298

版权

7. DQN

DQN 算法 (boyuai.com)

7.1 简介

在 Q-learning 算法中，我们以矩阵的方式建立了一张存储每个状态下所有动作 $Q$ 值的表格。表格中的每一个动作价值 $Q(s,a)$ 表示在状态s下选择动作a然后继续遵循某一策略预期能够得到的期望回报。然而，这种用表格存储动作价值的做法只在环境的状态和动作都是离散的，并且空间都比较小的情况下适用，我们之前进行代码实战的几个环境都是如此（如悬崖漫步）。当状态或者动作数量非常大的时候，这种做法就不适用了。例如，当状态是一张 RGB 图像时，假设图像大小是210x160x3，此时一共有种状态 $256^{(210\times 60\times 3)}$ ，在计算机中存储这个数量级的值表格是不现实的。更甚者，当状态或者动作连续的时候，就有无限个状态动作对，我们更加无法使用这种表格形式来记录各个状态动作对的值。

对于这种情况，我们需要用函数拟合的方法来估计值，即将这个复杂的值表格视作数据，使用一个参数化的函数 $Q_\theta$ 来拟合这些数据。很显然，这种函数拟合的方法存在一定的精度损失，因此被称为近似方法。我们今天要介绍的 DQN 算法便可以用来解决连续状态下离散动作的问题。

7.2 CartPole 环境

以图 7-1 中所示的所示的车杆（CartPole）环境为例，它的状态值就是连续的，动作值是离散的。

图 7-1 CartPole环境示意图

在车杆环境中，有一辆小车，智能体的任务是通过左右移动保持车上的杆竖直，若杆的倾斜度数过大，或者车子离初始位置左右的偏离程度过大，或者坚持时间到达 200 帧，则游戏结束。智能体的状态是一个维数为 4 的向量，每一维都是连续的，其动作是离散的，动作空间大小为 2，详情参见表 7-1 和表 7-2。在游戏中每坚持一帧，智能体能获得分数为 1 的奖励，坚持时间越长，则最后的分数越高，坚持 200 帧即可获得最高的分数。

表 7-1 CartPole环境的状态空间

维度	意义	最小值	最大值
0	车的位置	-2.4	2.4
1	车的速度	-Inf	Inf
2	杆的角度	~ -41.8°	~ 41.8°
3	杆尖端的速度	-Inf	Inf

表7-2 CartPole环境的动作空间

标号	动作
0	向左移动小车
1	向右移动小车

7.3 DQN

现在我们想在类似车杆的环境中得到动作价值函数 $Q(s,a)$ ，由于状态每一维度的值都是连续的，无法使用表格记录，因此一个常见的解决方法便是使用函数拟合（function approximation）的思想。由于神经网络具有强大的表达能力，因此我们可以用一个神经网络来表示函数 $Q$ 。若动作是连续（无限）的，神经网络的输入是状态S和动作a，然后输出一个标量，表示在状态s下采取动作a能获得的价值。若动作是离散（有限）的，除了可以采取动作连续情况下的做法，我们还可以只将状态输入到神经网络中，使其同时输出每一个动作的Q值。通常 DQN（以及 Q-learning）只能处理动作离散的情况，因为在函数Q的更新过程中 $max_a$ 有这一操作。假设神经网络用来拟合函数 $\omega$ 的参数是，即每一个状态下s所有可能动作a的Q值我们都能表示为 $Q_w(s,a)$ 。我们将用于拟合函数函数的神经网络称为Q 网络，如图 7-2 所示。

图7-2 工作在CartPole环境中的Q网络示意图

那么 Q 网络的损失函数是什么呢？我们先来回顾一下 Q-learning 的更新规则：

至此，我们就可以将 Q-learning 扩展到神经网络形式——深度 Q 网络（deep Q network，DQN）算法。由于 DQN 是离线策略算法，因此我们在收集数据的时候可以使用一个-贪婪策略来平衡探索与利用，将收集到的数据存储起来，在后续的训练中使用。DQN 中还有两个非常重要的模块——经验回放和目标网络，它们能够帮助 DQN 取得稳定、出色的性能。

7.3.1 经验回放

在一般的有监督学习中，假设训练数据是独立同分布的，我们每次训练神经网络的时候从训练数据中随机采样一个或若干个数据来进行梯度下降，随着学习的不断进行，每一个训练数据会被使用多次。在原来的 Q-learning 算法中，每一个数据只会用来更新一次值。为了更好地将 Q-learning 和深度神经网络结合，DQN 算法采用了经验回放（experience replay）方法，具体做法为维护一个回放缓冲区，将每次从环境中采样得到的四元组数据（状态、动作、奖励、下一状态）存储到回放缓冲区中，训练 Q 网络的时候再从回放缓冲区中随机采样若干数据来进行训练。这么做可以起到以下两个作用。

（1）使样本满足独立假设。在 MDP 中交互采样得到的数据本身不满足独立假设，因为这一时刻的状态和上一时刻的状态有关。非独立同分布的数据对训练神经网络有很大的影响，会使神经网络拟合到最近训练的数据上。采用经验回放可以打破样本之间的相关性，让其满足独立假设。

（2）提高样本效率。每一个样本可以被使用多次，十分适合深度神经网络的梯度学习。

7.3.2 目标网络

DQN 算法最终更新的目标是让 $Q_w(s,a)$ 逼近 $r+\gamma max_{a'}Q_w(s',a')$ ，由于 TD 误差目标本身就包含神经网络的输出，因此在更新网络参数的同时目标也在不断地改变，这非常容易造成神经网络训练的不稳定性。为了解决这一问题，DQN 便使用了目标网络（target network）的思想：既然训练过程中 Q 网络的不断更新会导致目标不断发生改变，不如暂时先将 TD 目标中的 Q 网络固定住。为了实现这一思想，我们需要利用两套 Q 网络。

(1)原来的训练网络 $Q_w(s,a)$ ，用于计算原来的损失函数 $\frac{1}{2}[{Q_w(s,a)-(r+\gamma max_{a'}Q_{w^-}(s',a'))}]^2$ 中的 $Q_{w}(s,a)$ 项，并且使用正常梯度下降方法来进行更新。

(2) 目标网络 $Q_{w^-}(s,a))$ ， $\frac{1}{2}[{Q_w(s,a)-(r+\gamma max_{a'}Q_{w^-}(s',a'))}]^2$ 中的 $(r+\gamma max_{a'}Q_{w^-}(s',a'))$ 项，其中 $w^-$ 表示目标网络中的参数。如果两套网络的参数随时保持一致，则仍为原先不够稳定的算法。为了让更新目标更稳定，目标网络并不会每一步都更新。具体而言，目标网络使用训练网络的一套较旧的参数，训练网络 $Q_w(s,a)$ 在训练中的每一步都会更新，而目标网络的参数每隔C步才会与训练网络同步一次，即 $w^-\leftarrow w$ 。这样做使得目标网络相对于训练网络更加稳定。

综上所述，DQN 算法的具体流程如下：

7.4 实践

接下来，我们就正式进入 DQN 算法的代码实践环节。我们采用的测试环境是 CartPole-v0，其状态空间相对简单，只有 4 个变量，因此网络结构的设计也相对简单：采用一层 128 个神经元的全连接并以 ReLU 作为激活函数。当遇到更复杂的诸如以图像作为输入的环境时，我们可以考虑采用深度卷积神经网络。

从 DQN 算法开始，我们将会用到rl_utils库，它包含一些专门为本书准备的函数，如绘制移动平均曲线、计算优势函数等，不同的算法可以一起使用这些函数。为了能够调用rl_utils库，请从本书的GitHub 仓库下载rl_utils.py文件。

import random

import gym

import numpy as np

import collections

from tqdm import tqdm

import torch

import torch.nn.functional as F

import matplotlib.pyplot as plt

import rl_utils

首先定义经验回放池的类，主要包括加入数据、采样数据两大函数。

class ReplayBuffer:

''' 经验回放池 '''

def __init__(self, capacity):

self.buffer = collections.deque(maxlen=capacity) # 队列,先进先出

def add(self, state, action, reward, next_state, done): # 将数据加入buffer

self.buffer.append((state, action, reward, next_state, done))

def sample(self, batch_size): # 从buffer中采样数据,数量为batch_size

transitions = random.sample(self.buffer, batch_size)

state, action, reward, next_state, done = zip(*transitions)

return np.array(state), action, reward, np.array(next_state), done

def size(self): # 目前buffer中数据的数量

return len(self.buffer)

然后定义一个只有一层隐藏层的 Q 网络。

class Qnet(torch.nn.Module):

''' 只有一层隐藏层的Q网络 '''

def __init__(self, state_dim, hidden_dim, action_dim):

super(Qnet, self).__init__()

self.fc1 = torch.nn.Linear(state_dim, hidden_dim)

self.fc2 = torch.nn.Linear(hidden_dim, action_dim)

def forward(self, x):

x = F.relu(self.fc1(x)) # 隐藏层使用ReLU激活函数

return self.fc2(x)

有了这些基本组件之后，接来下开始实现 DQN 算法。

class DQN:

''' DQN算法 '''

def __init__(self, state_dim, hidden_dim, action_dim, learning_rate, gamma,

epsilon, target_update, device):

self.action_dim = action_dim

self.q_net = Qnet(state_dim, hidden_dim,

self.action_dim).to(device) # Q网络

# 目标网络

self.target_q_net = Qnet(state_dim, hidden_dim,

self.action_dim).to(device)

# 使用Adam优化器

self.optimizer = torch.optim.Adam(self.q_net.parameters(),

lr=learning_rate)

self.gamma = gamma # 折扣因子

self.epsilon = epsilon # epsilon-贪婪策略

self.target_update = target_update # 目标网络更新频率

self.count = 0 # 计数器,记录更新次数

self.device = device

def take_action(self, state): # epsilon-贪婪策略采取动作

if np.random.random() < self.epsilon:

action = np.random.randint(self.action_dim)

else:

state = torch.tensor([state], dtype=torch.float).to(self.device)

action = self.q_net(state).argmax().item()

return action

def update(self, transition_dict):

states = torch.tensor(transition_dict['states'],

dtype=torch.float).to(self.device)

actions = torch.tensor(transition_dict['actions']).view(-1, 1).to(

self.device)

rewards = torch.tensor(transition_dict['rewards'],

dtype=torch.float).view(-1, 1).to(self.device)

next_states = torch.tensor(transition_dict['next_states'],

dtype=torch.float).to(self.device)

dones = torch.tensor(transition_dict['dones'],

dtype=torch.float).view(-1, 1).to(self.device)

q_values = self.q_net(states).gather(1, actions) # Q值

# 下个状态的最大Q值

max_next_q_values = self.target_q_net(next_states).max(1)[0].view(

-1, 1)

q_targets = rewards + self.gamma * max_next_q_values * (1 - dones

) # TD误差目标

dqn_loss = torch.mean(F.mse_loss(q_values, q_targets)) # 均方误差损失函数

self.optimizer.zero_grad() # PyTorch中默认梯度会累积,这里需要显式将梯度置为0

dqn_loss.backward() # 反向传播更新参数

self.optimizer.step()

if self.count % self.target_update == 0:

self.target_q_net.load_state_dict(

self.q_net.state_dict()) # 更新目标网络

self.count += 1

一切准备就绪，开始训练并查看结果。我们之后会将这一训练过程包装进rl_utils库中，方便之后要学习的算法的代码实现。

lr = 2e-3

num_episodes = 500

hidden_dim = 128

gamma = 0.98

epsilon = 0.01

target_update = 10

buffer_size = 10000

minimal_size = 500

batch_size = 64

device = torch.device("cuda") if torch.cuda.is_available() else torch.device(

"cpu")

env_name = 'CartPole-v0'

env = gym.make(env_name)

random.seed(0)

np.random.seed(0)

env.seed(0)

torch.manual_seed(0)

replay_buffer = ReplayBuffer(buffer_size)

state_dim = env.observation_space.shape[0]

action_dim = env.action_space.n

agent = DQN(state_dim, hidden_dim, action_dim, lr, gamma, epsilon,

target_update, device)

return_list = []

for i in range(10):

with tqdm(total=int(num_episodes / 10), desc='Iteration %d' % i) as pbar:

for i_episode in range(int(num_episodes / 10)):

episode_return = 0

state = env.reset()

done = False

while not done:

action = agent.take_action(state)

next_state, reward, done, _ = env.step(action)

replay_buffer.add(state, action, reward, next_state, done)

state = next_state

episode_return += reward

# 当buffer数据的数量超过一定值后,才进行Q网络训练

if replay_buffer.size() > minimal_size:

b_s, b_a, b_r, b_ns, b_d = replay_buffer.sample(batch_size)

transition_dict = {

'states': b_s,

'actions': b_a,

'next_states': b_ns,

'rewards': b_r,

'dones': b_d

}

agent.update(transition_dict)

return_list.append(episode_return)

if (i_episode + 1) % 10 == 0:

pbar.set_postfix({

'episode':

'%d' % (num_episodes / 10 * i + i_episode + 1),

'return':

'%.3f' % np.mean(return_list[-10:])

})

pbar.update(1)

Iteration 0: 100%|██████████████████████████████████████████| 50/50 [00:00<00:00, 589.55it/s, episode=50, return=9.300]

Iteration 1: 100%|█████████████████████████████████████████| 50/50 [00:00<00:00, 60.01it/s, episode=100, return=12.300]

Iteration 2: 100%|████████████████████████████████████████| 50/50 [00:04<00:00, 11.94it/s, episode=150, return=123.000]

Iteration 3: 100%|████████████████████████████████████████| 50/50 [00:15<00:00, 3.27it/s, episode=200, return=159.300]

Iteration 4: 100%|████████████████████████████████████████| 50/50 [00:16<00:00, 3.04it/s, episode=250, return=192.200]

Iteration 5: 100%|████████████████████████████████████████| 50/50 [00:15<00:00, 3.23it/s, episode=300, return=199.900]

Iteration 6: 100%|████████████████████████████████████████| 50/50 [00:15<00:00, 3.28it/s, episode=350, return=193.400]

Iteration 7: 100%|████████████████████████████████████████| 50/50 [00:16<00:00, 3.10it/s, episode=400, return=200.000]

Iteration 8: 100%|████████████████████████████████████████| 50/50 [00:15<00:00, 3.28it/s, episode=450, return=172.300]

Iteration 9: 100%|████████████████████████████████████████| 50/50 [00:15<00:00, 3.32it/s, episode=500, return=185.000]

episodes_list = list(range(len(return_list)))

plt.plot(episodes_list, return_list)

plt.xlabel('Episodes')

plt.ylabel('Returns')

plt.title('DQN on {}'.format(env_name))

plt.show()

mv_return = rl_utils.moving_average(return_list, 9)

plt.plot(episodes_list, mv_return)

plt.xlabel('Episodes')

plt.ylabel('Returns')

plt.title('DQN on {}'.format(env_name))

plt.show()

可以看到，DQN 的性能在 100 个序列后很快得到提升，最终收敛到策略的最优回报值 200。我们也可以看到，在 DQN 的性能得到提升后，它会持续出现一定程度的震荡，这主要是神经网络过拟合到一些局部经验数据后由运算带来的影响。

7.5 以图像为输入的 DQN 算法

在本书前面章节所述的强化学习环境中，我们都使用非图像的状态作为输入（例如车杆环境中车的坐标、速度），但是在一些视频游戏中，智能体并不能直接获取这些状态信息，而只能直接获取屏幕中的图像。要让智能体和人一样玩游戏，我们需要让智能体学会以图像作为状态时的决策。我们可以利用 7.4 节的 DQN 算法，将卷积层加入其网络结构以提取图像特征，最终实现以图像为输入的强化学习。以图像为输入的 DQN 算法的代码与 7.4 节的代码的不同之处主要在于 Q 网络的结构和数据输入。DQN 网络通常会将最近的几帧图像一起作为输入，从而感知环境的动态性。接下来我们实现以图像为输入的 DQN 算法，但由于代码需要运行较长的时间，我们在此便不展示训练结果。

class ConvolutionalQnet(torch.nn.Module):

''' 加入卷积层的Q网络 '''

def __init__(self, action_dim, in_channels=4):

super(ConvolutionalQnet, self).__init__()

self.conv1 = torch.nn.Conv2d(in_channels, 32, kernel_size=8, stride=4)

self.conv2 = torch.nn.Conv2d(32, 64, kernel_size=4, stride=2)

self.conv3 = torch.nn.Conv2d(64, 64, kernel_size=3, stride=1)

self.fc4 = torch.nn.Linear(7 * 7 * 64, 512)

self.head = torch.nn.Linear(512, action_dim)

def forward(self, x):

x = x / 255

x = F.relu(self.conv1(x))

x = F.relu(self.conv2(x))

x = F.relu(self.conv3(x))

x = F.relu(self.fc4(x))

return self.head(x)

7.6 小结

本章讲解了 DQN 算法，其主要思想是用一个神经网络来表示最优策略的函数，然后利用 Q-learning 的思想进行参数更新。为了保证训练的稳定性和高效性，DQN 算法引入了经验回放和目标网络两大模块，使得算法在实际应用时能够取得更好的效果。在 2013 年的 NIPS 深度学习研讨会上，DeepMind 公司的研究团队发表了 DQN 论文，首次展示了这一直接通过卷积神经网络接受像素输入来玩转各种雅达利（Atari）游戏的强化学习算法，由此拉开了深度强化学习的序幕。DQN 是深度强化学习的基础，掌握了该算法才算是真正进入了深度强化学习领域，本书中还有更多的深度强化学习算法等待读者探索。

7.7 参考文献

[1] VOLODYMYR M, KAVUKCUOGLU K, SILVER D, et al. Human-level control through deep reinforcement learning [J]. Nature, 2015, 518(7540): 529-533.

[2] VOLODYMYR M, KAVUKCUOGLU K, SILVER D, et al. Playing atari with deep reinforcement learning [C]//NIPS Deep Learning Workshop, 2013.

[3]DQN 算法 (boyuai.com)

第 9 章策略梯度算法

策略梯度算法 (boyuai.com)

9.1 简介

本书之前介绍的 Q-learning、DQN 及 DQN 改进算法都是基于价值（value-based）的方法，其中 Q-learning 是处理有限状态的算法，而 DQN 可以用来解决连续状态的问题。在强化学习中，除了基于值函数的方法，还有一支非常经典的方法，那就是基于策略（policy-based）的方法。对比两者，基于值函数的方法主要是学习值函数，然后根据值函数导出一个策略，学习过程中并不存在一个显式的策略；而基于策略的方法则是直接显式地学习一个目标策略。策略梯度是基于策略的方法的基础，本章从策略梯度算法说起。

9.2 策略梯度

基于策略的方法首先需要将策略参数化。假设目标策略是一个随机性策略，并且处处可微，其中是对应的参数。我们可以用一个线性模型或者神经网络模型来为这样一个策略函数建模，输入某个状态，然后输出一个动作的概率分布。我们的目标是要寻找一个最优策略并最大化这个策略在环境中的期望回报。我们将策略学习的目标函数定义为

$J(\theta )=E_{s0}[V^{\pi_\theta}(s_0)]$

其中， $s_0$ 表示初始状态。现在有了目标函数，我们将目标函数对策略 $\theta$ 求导，得到导数后，就可以用梯度上升方法来最大化这个目标函数，从而得到最优策略。

我第 3 章讲解过策略下的状态访问分布，在此用表示。然后我们对目标函数求梯度，可以得到如下式子，更详细的推导过程将在 9.6 节给出。

这个梯度可以用来更新策略。需要注意的是，因为上式中期望E的下标是 $\pi_\theta$ ，所以策略梯度算法为在线策略（on-policy）算法，即必须使用当前策略采样得到的数据来计算梯度。直观理解一下策略梯度这个公式，可以发现在每一个状态下，梯度的修改是让策略更多地去采样到带来较高Q值的动作，更少地去采样到带来较低值的动作，如图 9-1 所示。

图9-1 策略梯度示意图

在计算策略梯度的公式中，我们需要用到 $Q^{\pi_\theta}(s,a)$ ，可以用多种方式对它进行估计。接下来要介绍的 REINFORCE 算法便是采用了蒙特卡洛方法来估计，对于一个有限步数的环境来说，REINFORCE 算法中的策略梯度为：

其中，T是和环境交互的最大步数。例如，在车杆环境中，T=200步。

9.3 REINFORCE

REINFORCE 算法的具体算法流程如下：

这便是 REINFORCE 算法的全部流程了。接下来让我们来用代码来实现它，看看效果如何吧！

9.4 REINFORCE 代码实践

我们在车杆环境中进行 REINFORCE 算法的实验。

import gym

import torch

import torch.nn.functional as F

import numpy as np

import matplotlib.pyplot as plt

from tqdm import tqdm

import rl_utils

首先定义策略网络PolicyNet，其输入是某个状态，输出则是该状态下的动作概率分布，这里采用在离散动作空间上的softmax()函数来实现一个可学习的多项分布（multinomial distribution）。

class PolicyNet(torch.nn.Module):

def __init__(self, state_dim, hidden_dim, action_dim):

super(PolicyNet, self).__init__()

self.fc1 = torch.nn.Linear(state_dim, hidden_dim)

self.fc2 = torch.nn.Linear(hidden_dim, action_dim)

def forward(self, x):

x = F.relu(self.fc1(x))

return F.softmax(self.fc2(x), dim=1)

再定义我们的 REINFORCE 算法。在函数take_action()函数中，我们通过动作概率分布对离散的动作进行采样。在更新过程中，我们按照算法将损失函数写为策略回报的负数，即，对求导后就可以通过梯度下降来更新策略。

class REINFORCE:

def __init__(self, state_dim, hidden_dim, action_dim, learning_rate, gamma,

device):

self.policy_net = PolicyNet(state_dim, hidden_dim,

action_dim).to(device)

self.optimizer = torch.optim.Adam(self.policy_net.parameters(),

lr=learning_rate) # 使用Adam优化器

self.gamma = gamma # 折扣因子

self.device = device

def take_action(self, state): # 根据动作概率分布随机采样

state = torch.tensor([state], dtype=torch.float).to(self.device)

probs = self.policy_net(state)

action_dist = torch.distributions.Categorical(probs)

action = action_dist.sample()

return action.item()

def update(self, transition_dict):

reward_list = transition_dict['rewards']

state_list = transition_dict['states']

action_list = transition_dict['actions']

G = 0

self.optimizer.zero_grad()

for i in reversed(range(len(reward_list))): # 从最后一步算起

reward = reward_list[i]

state = torch.tensor([state_list[i]],

dtype=torch.float).to(self.device)

action = torch.tensor([action_list[i]]).view(-1, 1).to(self.device)

log_prob = torch.log(self.policy_net(state).gather(1, action))

G = self.gamma * G + reward

loss = -log_prob * G # 每一步的损失函数

loss.backward() # 反向传播计算梯度

self.optimizer.step() # 梯度下降

定义好策略，我们就可以开始实验了，看看 REINFORCE 算法在车杆环境上表现如何吧！


learning_rate = 1e-3

num_episodes = 1000

hidden_dim = 128

gamma = 0.98

device = torch.device("cuda") if torch.cuda.is_available() else torch.device(

"cpu")

env_name = "CartPole-v0"

env = gym.make(env_name)

env.seed(0)

torch.manual_seed(0)

state_dim = env.observation_space.shape[0]

action_dim = env.action_space.n

agent = REINFORCE(state_dim, hidden_dim, action_dim, learning_rate, gamma,

device)

return_list = []

for i in range(10):

with tqdm(total=int(num_episodes / 10), desc='Iteration %d' % i) as pbar:

for i_episode in range(int(num_episodes / 10)):

episode_return = 0

transition_dict = {

'states': [],

'actions': [],

'next_states': [],

'rewards': [],

'dones': []

}

state = env.reset()

done = False

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_list.append(episode_return)

agent.update(transition_dict)

if (i_episode + 1) % 10 == 0:

pbar.set_postfix({

'episode':

'%d' % (num_episodes / 10 * i + i_episode + 1),

'return':

'%.3f' % np.mean(return_list[-10:])

})

pbar.update(1)

Iteration 0: 100%|███████████████████████████████████████| 100/100 [00:02<00:00, 47.36it/s, episode=100, return=55.500]

Iteration 1: 100%|███████████████████████████████████████| 100/100 [00:04<00:00, 21.26it/s, episode=200, return=75.300]

Iteration 2: 100%|██████████████████████████████████████| 100/100 [00:09<00:00, 10.55it/s, episode=300, return=178.800]

Iteration 3: 100%|██████████████████████████████████████| 100/100 [00:11<00:00, 8.74it/s, episode=400, return=164.600]

Iteration 4: 100%|██████████████████████████████████████| 100/100 [00:11<00:00, 8.74it/s, episode=500, return=156.500]

Iteration 5: 100%|██████████████████████████████████████| 100/100 [00:11<00:00, 8.54it/s, episode=600, return=187.400]

Iteration 6: 100%|██████████████████████████████████████| 100/100 [00:11<00:00, 8.52it/s, episode=700, return=194.500]

Iteration 7: 100%|██████████████████████████████████████| 100/100 [00:13<00:00, 7.57it/s, episode=800, return=200.000]

Iteration 8: 100%|██████████████████████████████████████| 100/100 [00:12<00:00, 7.84it/s, episode=900, return=200.000]

Iteration 9: 100%|█████████████████████████████████████| 100/100 [00:12<00:00, 7.89it/s, episode=1000, return=186.100]

在 CartPole-v0 环境中，满分就是 200 分，我们发现 REINFORCE 算法效果很好，可以达到 200 分。接下来我们绘制训练过程中每一条轨迹的回报变化图。由于回报抖动比较大，往往会进行平滑处理。

episodes_list = list(range(len(return_list)))

plt.plot(episodes_list, return_list)

plt.xlabel('Episodes')

plt.ylabel('Returns')

plt.title('REINFORCE on {}'.format(env_name))

plt.show()

mv_return = rl_utils.moving_average(return_list, 9)

plt.plot(episodes_list, mv_return)

plt.xlabel('Episodes')

plt.ylabel('Returns')

plt.title('REINFORCE on {}'.format(env_name))

plt.show()

可以看到，随着收集到的轨迹越来越多，REINFORCE 算法有效地学习到了最优策略。不过，相比于前面的 DQN 算法，REINFORCE 算法使用了更多的序列，这是因为 REINFORCE 算法是一个在线策略算法，之前收集到的轨迹数据不会被再次利用。此外，REINFORCE 算法的性能也有一定程度的波动，这主要是因为每条采样轨迹的回报值波动比较大，这也是 REINFORCE 算法主要的不足。

9.5 小结

REINFORCE 算法是策略梯度乃至强化学习的典型代表，智能体根据当前策略直接和环境交互，通过采样得到的轨迹数据直接计算出策略参数的梯度，进而更新当前策略，使其向最大化策略期望回报的目标靠近。这种学习方式是典型的从交互中学习，并且其优化的目标（即策略期望回报）正是最终所使用策略的性能，这比基于价值的强化学习算法的优化目标（一般是时序差分误差的最小化）要更加直接。 REINFORCE 算法理论上是能保证局部最优的，它实际上是借助蒙特卡洛方法采样轨迹来估计动作价值，这种做法的一大优点是可以得到无偏的梯度。但是，正是因为使用了蒙特卡洛方法，REINFORCE 算法的梯度估计的方差很大，可能会造成一定程度上的不稳定，这也是第 10 章将介绍的 Actor-Critic 算法要解决的问题。

9.6 扩展阅读：策略梯度证明

证明完毕！

9.7 参考文献

[1] SUTTON R S, MCALLESTER D A, SINGH S P, et al. Policy gradient methods for reinforcement learning with function approximation [C] // Advances in neural information processing systems, 2000: 1057-1063.

第 10 章 Actor-Critic 算法

参考Actor-Critic 算法 (boyuai.com)

10.1 简介

本书之前的章节讲解了基于值函数的方法（DQN）和基于策略的方法（REINFORCE），其中基于值函数的方法只学习一个价值函数，而基于策略的方法只学习一个策略函数。那么，一个很自然的问题是，有没有什么方法既学习价值函数，又学习策略函数呢？答案就是 Actor-Critic。Actor-Critic 是囊括一系列算法的整体架构，目前很多高效的前沿算法都属于 Actor-Critic 算法，本章接下来将会介绍一种最简单的 Actor-Critic 算法。需要明确的是，Actor-Critic 算法本质上是基于策略的算法，因为这一系列算法的目标都是优化一个带参数的策略，只是会额外学习价值函数，从而帮助策略函数更好地学习。

10.2 Actor-Critic

回顾一下，在 REINFORCE 算法中，目标函数的梯度中有一项轨迹回报，用于指导策略的更新。REINFOCE 算法用蒙特卡洛方法来估计，能不能考虑拟合一个值函数来指导策略进行学习呢？这正是 Actor-Critic 算法所做的。在策略梯度中，可以把梯度写成下面这个更加一般的形式：

其中，可以有很多种形式：

轨迹的总回报；动作之后的回报；基准线版本的改进；动作价值函数；优势函数；时序差分残差。

9.5 节提到 REINFORCE 通过蒙特卡洛采样的方法对策略梯度的估计是无偏的，但是方差非常大。我们可以用形式(3)引入基线函数（baseline function） $b(s_t)$ 来减小方差。此外，我们也可以采用 Actor-Critic 算法估计一个动作价值函数，代替蒙特卡洛采样得到的回报，这便是形式(4)。这个时候，我们可以把状态价值函数 $V$ 作为基线，从函数 $Q$ 减去这个函数 $V$ 则得到了函数，我们称之为优势函数（advantage function），这便是形式(5)(备注PPO算法是用advantage函数，参考PPO(Proximal Policy Optimization)算法原理及实现,详解近端策略优化-CSDN博客）。更进一步，我们可以利用 $Q=r+\gamma V$ 等式得到形式(6)。

本章将着重介绍形式(6)，即通过时序差分残差 $\psi =r_t+\gamma V^{\pi}(s_{t+1}-V^{\pi}(s_t))$ 来指导策略梯度进行学习。事实上，用Q值或者V值本质上也是用奖励来进行指导，但是用神经网络进行估计的方法可以减小方差、提高鲁棒性。除此之外，REINFORCE 算法基于蒙特卡洛采样，只能在序列结束后进行更新，这同时也要求任务具有有限的步数，而 Actor-Critic 算法则可以在每一步之后都进行更新，并且不对任务的步数做限制。

我们将 Actor-Critic 分为两个部分：Actor（策略网络）和 Critic（价值网络），如图 10-1 所示。

Actor 要做的是与环境交互，并在 Critic 价值函数的指导下用策略梯度学习一个更好的策略。
Critic 要做的是通过 Actor 与环境交互收集的数据学习一个价值函数，这个价值函数会用于判断在当前状态什么动作是好的，什么动作不是好的，进而帮助 Actor 进行策略更新。

图10-1 Actor 和 Critic 的关系

Actor 的更新采用策略梯度的原则，那 Critic 如何更新呢？我们将 Critic 价值网络表示为 $V_w$ ，参数为 $w$ 。于是，我们可以采取时序差分残差的学习方式，对于单个数据定义如下价值函数的损失函数：

与 DQN 中一样，我们采取类似于目标网络的方法，将上式 $r+\gamma V_w(s_{t+1})$ 中作为时序差分目标，不会产生梯度来更新价值函数。因此，价值函数的梯度为：

然后使用梯度下降方法来更新 Critic 价值网络参数即可。

Actor-Critic 算法的具体流程如下：

以上就是 Actor-Critic 算法的流程，接下来让我们来用代码实现它，看看效果如何吧！

10.3 Actor-Critic 代码实践

我们仍然在车杆环境上进行 Actor-Critic 算法的实验。

import gym

import torch

import torch.nn.functional as F

import numpy as np

import matplotlib.pyplot as plt

import rl_utils

首先定义策略网络PolicyNet（与 REINFORCE 算法一样）。

class PolicyNet(torch.nn.Module):

def __init__(self, state_dim, hidden_dim, action_dim):

super(PolicyNet, self).__init__()

self.fc1 = torch.nn.Linear(state_dim, hidden_dim)

self.fc2 = torch.nn.Linear(hidden_dim, action_dim)

def forward(self, x):

x = F.relu(self.fc1(x))

return F.softmax(self.fc2(x), dim=1)

Actor-Critic 算法中额外引入一个价值网络，接下来的代码定义价值网络ValueNet，其输入是某个状态，输出则是状态的价值。

class ValueNet(torch.nn.Module):

def __init__(self, state_dim, hidden_dim):

super(ValueNet, self).__init__()

self.fc1 = torch.nn.Linear(state_dim, hidden_dim)

self.fc2 = torch.nn.Linear(hidden_dim, 1)

def forward(self, x):

x = F.relu(self.fc1(x))

return self.fc2(x)

现在定义ActorCritic算法，主要包含采取动作（take_action()）和更新网络参数（update()）两个函数。

class ActorCritic:

def __init__(self, state_dim, hidden_dim, action_dim, actor_lr, critic_lr,

gamma, device):

# 策略网络

self.actor = PolicyNet(state_dim, hidden_dim, action_dim).to(device)

self.critic = ValueNet(state_dim, hidden_dim).to(device) # 价值网络

# 策略网络优化器

self.actor_optimizer = torch.optim.Adam(self.actor.parameters(),

lr=actor_lr)

self.critic_optimizer = torch.optim.Adam(self.critic.parameters(),

lr=critic_lr) # 价值网络优化器

self.gamma = gamma

self.device = device

def take_action(self, state):

state = torch.tensor([state], dtype=torch.float).to(self.device)

probs = self.actor(state)

action_dist = torch.distributions.Categorical(probs)

action = action_dist.sample()

return action.item()

def update(self, transition_dict):

states = torch.tensor(transition_dict['states'],

dtype=torch.float).to(self.device)

actions = torch.tensor(transition_dict['actions']).view(-1, 1).to(

self.device)

rewards = torch.tensor(transition_dict['rewards'],

dtype=torch.float).view(-1, 1).to(self.device)

next_states = torch.tensor(transition_dict['next_states'],

dtype=torch.float).to(self.device)

dones = torch.tensor(transition_dict['dones'],

dtype=torch.float).view(-1, 1).to(self.device)

# 时序差分目标

td_target = rewards + self.gamma * self.critic(next_states) * (1 -

dones)

td_delta = td_target - self.critic(states) # 时序差分误差

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()))

self.actor_optimizer.zero_grad()

self.critic_optimizer.zero_grad()

actor_loss.backward() # 计算策略网络的梯度

critic_loss.backward() # 计算价值网络的梯度

self.actor_optimizer.step() # 更新策略网络的参数

self.critic_optimizer.step() # 更新价值网络的参数

定义好 Actor 和 Critic，我们就可以开始实验了，看看 Actor-Critic 在车杆环境上表现如何吧！

actor_lr = 1e-3

critic_lr = 1e-2

num_episodes = 1000

hidden_dim = 128

gamma = 0.98

device = torch.device("cuda") if torch.cuda.is_available() else torch.device(

"cpu")

env_name = 'CartPole-v0'

env = gym.make(env_name)

env.seed(0)

torch.manual_seed(0)

state_dim = env.observation_space.shape[0]

action_dim = env.action_space.n

agent = ActorCritic(state_dim, hidden_dim, action_dim, actor_lr, critic_lr,

gamma, device)

return_list = rl_utils.train_on_policy_agent(env, agent, num_episodes)

Iteration 0: 0%| | 0/100 [00:00<?, ?it/s]/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:15: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at ../torch/csrc/utils/tensor_new.cpp:201.)

from ipykernel import kernelapp as app

Iteration 0: 100%|██████████| 100/100 [00:00<00:00, 101.75it/s, episode=100, return=21.100]

Iteration 1: 100%|██████████| 100/100 [00:01<00:00, 58.71it/s, episode=200, return=72.800]

Iteration 2: 100%|██████████| 100/100 [00:05<00:00, 19.73it/s, episode=300, return=109.300]

Iteration 3: 100%|██████████| 100/100 [00:05<00:00, 17.30it/s, episode=400, return=163.000]

Iteration 4: 100%|██████████| 100/100 [00:06<00:00, 16.27it/s, episode=500, return=193.600]

Iteration 5: 100%|██████████| 100/100 [00:06<00:00, 15.90it/s, episode=600, return=195.900]

Iteration 6: 100%|██████████| 100/100 [00:06<00:00, 15.80it/s, episode=700, return=199.100]

Iteration 7: 100%|██████████| 100/100 [00:06<00:00, 15.72it/s, episode=800, return=186.900]

Iteration 8: 100%|██████████| 100/100 [00:06<00:00, 15.94it/s, episode=900, return=200.000]

Iteration 9: 100%|██████████| 100/100 [00:06<00:00, 15.45it/s, episode=1000, return=200.000]

在 CartPole-v0 环境中，满分就是 200 分。和 REINFORCE 相似，接下来我们绘制训练过程中每一条轨迹的回报变化图以及其经过平滑处理的版本。

episodes_list = list(range(len(return_list)))

plt.plot(episodes_list, return_list)

plt.xlabel('Episodes')

plt.ylabel('Returns')

plt.title('Actor-Critic on {}'.format(env_name))

plt.show()

mv_return = rl_utils.moving_average(return_list, 9)

plt.plot(episodes_list, mv_return)

plt.xlabel('Episodes')

plt.ylabel('Returns')

plt.title('Actor-Critic on {}'.format(env_name))

plt.show()

根据实验结果我们可以发现，Actor-Critic 算法很快便能收敛到最优策略，并且训练过程非常稳定，抖动情况相比 REINFORCE 算法有了明显的改进，这说明价值函数的引入减小了方差。

10.4 总结

本章讲解了 Actor-Critic 算法，它是基于值函数的方法和基于策略的方法的叠加。价值模块 Critic 在策略模块 Actor 采样的数据中学习分辨什么是好的动作，什么不是好的动作，进而指导 Actor 进行策略更新。随着 Actor 的训练的进行，其与环境交互所产生的数据分布也发生改变，这需要 Critic 尽快适应新的数据分布并给出好的判别。

Actor-Critic 算法非常实用，后续章节中的 TRPO、PPO、DDPG、SAC 等深度强化学习算法都是在 Actor-Critic 框架下进行发展的。深入了解 Actor-Critic 算法对读懂目前深度强化学习的研究热点大有裨益。

10.5 参考文献

[1] KONDA, V R, TSITSIKLIS J N. Actor-critic algorithms [C]// Advances in neural information processing systems, 2000.

Actor-Critic 算法 (boyuai.com)

蓝天白云大海沙滩Herman

关注

15
点赞
踩
18

收藏

觉得还不错? 一键收藏
1
评论
强化学习基础算法介绍，DQN，策略梯度算法，Actor-Critic算法

在 Q-learning 算法中，我们以矩阵的方式建立了一张存储每个状态下所有动作值的表格。表格中的每一个动作价值表示在状态s下选择动作a然后继续遵循某一策略预期能够得到的期望回报。然而，这种用表格存储动作价值的做法只在环境的状态和动作都是离散的，并且空间都比较小的情况下适用，我们之前进行代码实战的几个环境都是如此（如悬崖漫步）。当状态或者动作数量非常大的时候，这种做法就不适用了。例如，当状态是一张 RGB 图像时，假设图像大小是210x160x3，此时一共有种状态。
复制链接

扫一扫