大家好，今天和各位分享一下基于策略的深度强化学习方法，策略梯度法是对策略进行建模，然后通过梯度上升更新策略网络的参数。我们使用了 OpenAI 的 gym 库，基于策略梯度法完成了一个小游戏。完整代码可以从我的 GitHub 中获得：

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

1. 基于策略的深度强化学习

针对智能体在大规模离散动作下无法建模的难题，在基于值函数的深度强化学习中，利用神经网络对 Q 值函数近似估计，使深度学习与强化学习得到完美融合。

但是基于值函数的深度强化学习有一定的不足之处：

(1) 无法处理连续动作的任务。DQN 系列的算法可以较好地解决强化学习中大规模离散动作空间的任务，但在连续动作的任务中，难以实现利用深度神经网络对所有状态-动作的 Q 值函数近似表达。

(2) 无法处理环境中状态受到限制的问题。在基于值函数深度强化学习更新网络参数时，损失函数会依赖当前状态和下一个状态的值函数，当智能体在环境中观察的状态有限或建模受到限制时，就会导致实际环境中两个不同的状态有相同的价值函数，进而导致损失函数为零，出现梯度消失的问题。

(3) 智能体在环境中的探索性能较低。基于值函数的深度强化学习方法中，目标值都是从动作空间中选取一个最大价值的动作，导致智能体训练后的策略具有确定性，而面对一些需要随机策略进行探索的问题时，该方法就无法较好地解决。

由于基于值函数的深度强化学习存在上述的一些局限性，需要新的方法来解决这些问题，于是基于策略的深度强化学习被提出。该方法中将智能体当前的策略参数化，并且使用梯度的方法进行更新。

2. 策略梯度法

强化学习中策略梯度算法是对策略进行建模，然后通过梯度上升更新策略网络的参数。Policy Gradients 中无法使用策略的误差来构建损失函数，因为参数更新的目标是最大化累积奖励的期望值，所以策略更新的依据是某一动作对累积奖励的影响，即增加使累积回报变大的动作的概率，减弱使累积回报变小的动作的概率。

下图代表智能体在当前策略下，完成一个回合后构成的状态、动作序列 $r=\left \{ s_1,a_1,s_2,a_2,s_2,...s_T,a_T \right \}$ ，其中，Actor 是策略网络。每个回合结束后的累计回报为每个状态下采取的动作的奖励之和：

$R = \sum_{t=1}^{T}r_t$

智能体在环境中执行策略 $\pi_ \theta$ 后状态转移概率：

$P_{\theta }(\tau )=P(s_1)P(r_1,s_2|s_1,a_1)\cdots P_\theta (a_T,s_T)P(r_{T+1},s_T|s_T,a_T)$

$P_{\theta }(\tau ) = \prod_{t=1}^{T} ( P_\theta (a_t|s_t) P(r_t,s_{t+1} | s_t,a_t) )$

回合累计回报的期望：

$\bar{R}_\theta = \sum _{\tau } R(\tau ) P_\theta (\tau ) = E_{\tau \sim P_\theta (\tau )} [R(\tau )]$

通过微分公式可以得到累计回报的梯度为：

$\bigtriangledown \bar{R} _{\theta } = \sum_{\tau} R(\tau ) P_{\theta }(\tau) \bigtriangledown log P_\theta (\tau ) \approx \frac{1}{N} \sum_{n=1}^{N}\sum_{t=1}^{T} R(\tau ^n) \bigtriangledown log P_\theta (a_t^n | s_t^n)$

利用累计回报的梯度更新策略网络的参数：

$\theta ^ {new} \leftarrow \theta ^{old} + \beta \bigtriangledown \bar{R}_{\theta ^{old}}$

其中， $\beta$ 为梯度系数。通过上式的策略迭代可得，如果智能体在某个状态下采取的动作使累积回报增加，网络参数就会呈梯度上升趋势，该动作的概率就会增加，反之，梯度为下降趋势，减小该动作的概率。为了防止环境中所有的奖励都是正值，实现对于一些不好动作有一个负反馈，可以在总回报处减去一个基线。

3. 代码实现

策略函数 $\pi (a|s)$ 是一个概率密度函数，用于控制智能体的运动。 $\pi (a|s)$ 输入状态 s，输出每个动作 a 的概率分布。策略网络是指通过训练一个神经网络来近似策略函数。策略网络的参数 $\theta$ 可通过策略梯度算法进行更新，从而实现对策略网络 $\pi (a|s;\theta )$ 的训练。

伪代码如下

模型构建部分代码如下：

# 基于策略的学习方法，用于数值连续的问题
import numpy as np
import torch
from torch import nn
from torch.nn import functional as F
# —————————————————– #
#（1）构建训练网络
# —————————————————– #
class Net(nn.Module):
def __init__(self, n_states, n_hiddens, n_actions):
super(Net, 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, states]==>[b, n_hiddens]
x = F.relu(x)
x = self.fc2(x) # [b, n_hiddens]==>[b, n_actions]
# 对batch中的每一行样本计算softmax，q值越大，概率越大
x = F.softmax(x, dim=1) # [b, n_actions]==>[b, n_actions]
return x
# —————————————————– #
#（2）强化学习模型
# —————————————————– #
class PolicyGradient:
def __init__(self, n_states, n_hiddens, n_actions,
learning_rate, gamma):
# 属性分配
self.n_states = n_states # 状态数
self.n_hiddens = n_hiddens
self.n_actions = n_actions # 动作数
self.learning_rate = learning_rate # 衰减
self.gamma = gamma # 折扣因子
self._build_net() # 构建网络模型
# 网络构建
def _build_net(self):
# 网络实例化
self.policy_net = Net(self.n_states, self.n_hiddens, self.n_actions)
# 优化器
self.optimizer = torch.optim.Adam(self.policy_net.parameters(), lr=self.learning_rate)
# 动作选择，根据概率分布随机采样
def take_action(self, state): # 传入某个人的状态
# numpy[n_states]–>[1,n_states]–>tensor
state = torch.Tensor(state[np.newaxis, :])
# 获取每个人的各动作对应的概率[1,n_states]–>[1,n_actions]
probs = self.policy_net(state)
# 创建以probs为标准类型的数据分布
action_dist = torch.distributions.Categorical(probs)
# 以该概率分布随机抽样 [1,n_actions]–>[1] 每个状态取一组动作
action = action_dist.sample()
# 将tensor数据变成一个数 int
action = action.item()
return action
# 获取每个状态最大的state_value
def max_q_value(self, state):
# 维度变换[n_states]–>[1,n_states]
state = torch.tensor(state, dtype=torch.float).view(1,-1)
# 获取状态对应的每个动作的reward的最大值 [1,n_states]–>[1,n_actions]–>[1]–>float
max_q = self.policy_net(state).max().item()
return max_q
# 训练模型
def learn(self, transitions_dict): # 输入batch组状态[b,n_states]
# 取出该回合中所有的链信息
state_list = transitions_dict[‘states’]
action_list = transitions_dict[‘actions’]
reward_list = transitions_dict[‘rewards’]
G = 0 # 记录该条链的return
self.optimizer.zero_grad() # 优化器清0
# 梯度上升最大化目标函数
for i in reversed(range(len(reward_list))):
# 获取每一步的reward, float
reward = reward_list[i]
# 获取每一步的状态 [n_states]–>[1,n_states]
state = torch.tensor(state_list[i], dtype=torch.float).view(1,-1)
# 获取每一步的动作 [1]–>[1,1]
action = torch.tensor(action_list[i]).view(1,-1)
# 当前状态下的各个动作价值函数 [1,2]
q_value = self.policy_net(state)
# 获取已action对应的概率 [1,1]
log_prob = torch.log(q_value.gather(1, action))
# 计算当前状态的state_value = 及时奖励 + 下一时刻的state_value
G = reward + self.gamma * G
# 计算每一步的损失函数
loss = -log_prob * G
# 反向传播
loss.backward()
# 梯度下降
self.optimizer.step()