付款网站源码图片外链

策略梯度

强化学习算法进阶
Q-learning、DQN 及 DQN 改进算法都是基于价值（value-based）的方法，其中 Q-learning 是处理有限状态的算法，而 DQN 可以用来解决连续状态的问题。在强化学习中，除了基于值函数的方法，还有一支非常经典的方法，那就是基于策略（policy-based）的方法。对比两者：

• 基于值函数的方法主要是学习值函数，然后根据值函数导出一个策略，学习过程中并不存在一个显式的策略；
• 而基于策略的方法则是直接显式地学习一个目标策略。策略梯度是基于策略的方法的基础，本章从策略梯度算法说起。

基于策略的方法首先需要将策略参数化
假设目标策略 ${\pi }_{\theta }$是一个随机性策略，并且处处可微，其中θ是对应的参数。我们可以用一个线性模型或者神经网络模型来为这样一个策略函数建模，输入某个状态，然后输出一个动作的概率分布。我们的目标是要寻找一个最优策略并最大化这个策略在环境中的期望回报。我们将策略学习的目标函数定义为：$$J(\theta )={\mathbb{E}}_{s_0}[V^{{\pi }_{\theta }}(s_0)]$$其中， $s_0$表示初始状态。现在有了目标函数，我们将目标函数对策略θ求导，得到导数后，就可以用梯度上升方法来最大化这个目标函数，从而得到最优策略。
策略 $\pi$下的状态访问分布，在此用 ${\nu }^{\pi }$表示。然后我们对目标函数求梯度，可以得到如下式子：

$$\begin{array}{rl}{\nabla }_{\theta }J(\theta )& \propto \sum _{s\in S}{\nu }^{{\pi }_{\theta }}(s)\sum _{a\in A}{Q}^{{\pi }_{\theta }}(s,a){\nabla }_{\theta }{\pi }_{\theta }(a|s)\\ & =\sum _{s\in S}{\nu }^{{\pi }_{\theta }}(s)\sum _{a\in A}{\pi }_{\theta }(a|s)Q^{{\pi }_{\theta }}(s,a)\frac{{\nabla }_{\theta }{\pi }_{\theta }(a|s)}{{\pi }_{\theta }(a|s)}\\ & ={\mathbb{E}}_{{\pi }_{\theta }}[Q^{{\pi }_{\theta }}(s,a){\nabla }_{\theta }\log {\pi }_{\theta }(a|s)]\end{array}$$

符号说明

• ${\nabla }_{\theta }J(\theta )$：关于参数 $\theta$ 的目标函数 $J(\theta )$ 的梯度。目标函数 $J(\theta )$ 通常表示策略 ${\pi }_{\theta }$ 的期望回报，策略 ${\pi }_{\theta }(a|s)$ 是在状态 $s$ 下采取动作 $a$ 的概率，由参数 $\theta$ 决定。
• $S$：状态空间，即所有可能的状态集合。
• $A$：动作空间，即所有可能的动作集合。
• ${\nu }^{{\pi }_{\theta }}(s)$：在策略 ${\pi }_{\theta }$ 下状态 $s$ 的稳态分布（也叫占有度量），表示长期来看，智能体处于状态 $s$ 的概率。
• $Q^{{\pi }_{\theta }}(s,a)$：在策略 ${\pi }_{\theta }$ 下的状态 - 动作值函数，即从状态 $s$ 采取动作 $a$ 后，遵循策略 ${\pi }_{\theta }$ 所能获得的期望累积回报。
• ${\pi }_{\theta }(a|s)$：在状态 $s$ 下，根据策略 ${\pi }_{\theta }$ 采取动作 $a$ 的概率。
• ${\mathbb{E}}_{{\pi }_{\theta }}[\cdot ]$：在策略 ${\pi }_{\theta }$ 下的期望。

公式推导步骤

1. 第一步
   $${\nabla }_{\theta }J(\theta )\propto \sum _{s\in S}{\nu }^{{\pi }_{\theta }}(s)\sum _{a\in A}{Q}^{{\pi }_{\theta }}(s,a){\nabla }_{\theta }{\pi }_{\theta }(a|s)$$这一步表达了目标函数的梯度与状态 - 动作值函数和策略梯度的关系。它的含义是，目标函数的梯度可以通过对所有状态和动作的加权求和来近似，权重是状态的稳态分布和状态 - 动作值函数。

2. 第二步
   $$=\sum _{s\in S}{\nu }^{{\pi }_{\theta }}(s)\sum _{a\in A}{\pi }_{\theta }(a|s)Q^{{\pi }_{\theta }}(s,a)\frac{{\nabla }_{\theta }{\pi }_{\theta }(a|s)}{{\pi }_{\theta }(a|s)}$$这里通过将 ${\pi }_{\theta }(a|s)$ 乘进去再除出来，将式子变形。注意到 $\frac{{\nabla }_{\theta }{\pi }_{\theta }(a|s)}{{\pi }_{\theta }(a|s)}={\nabla }_{\theta }\log {\pi }_{\theta }(a|s)$，这是一个常见的对数求导技巧。

3. 第三步
   $$={\mathbb{E}}_{{\pi }_{\theta }}[Q^{{\pi }_{\theta }}(s,a){\nabla }_{\theta }\log {\pi }_{\theta }(a|s)]$$这一步将双重求和转化为期望形式。根据期望的定义，对于一个离散随机变量 $X$（这里是状态 - 动作对 $(s,a)$），其期望 $\mathbb{E}[X]={\sum }_i{p}_i{x}_i$，其中 $p_i$ 是取值 $x_i$ 的概率。在这里，${\nu }^{{\pi }_{\theta }}(s){\pi }_{\theta }(a|s)$ 是状态 - 动作对 $(s,a)$ 的联合概率分布，所以双重求和可以写成期望的形式。

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

在计算策略梯度的公式中，我们需要用到$Q^{{\pi }_{\theta }}(s,a)$，可以用多种方式对它进行估计。接下来要介绍的 REINFORCE 算法便是采用了蒙特卡洛方法来估计。

REINFORCE

对于一个有限步数的环境来说，REINFORCE 算法中的策略梯度为：$${\nabla }_{\theta }J(\theta )={\mathbb{E}}_{{\pi }_{\theta }}\left[\sum _{t=0}^T\left(\sum _{t^{\prime }=t}^T{\gamma }^{t^{\prime }-t}{r}_{t^{\prime }}\right){\nabla }_{\theta }\log {\pi }_{\theta }(a_t|s_t)\right]$$其中，$T$是和环境交互的最大步数。

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

• 初始化策略参数$\theta$
• for 序列 $e=1\to E$ do :
  • 用当前策略${\pi }_{\theta }$采样轨迹 { s 1 , a 1 , r 1 , s 2 , a 2 , r 2 , . . . , s T , a T , r T } \{s_1,a_1,r_1,s_2,a_2,r_2,...,s_T,a_T,r_T\} {s1​,a1​,r1​,s2​,a2​,r2​,...,sT​,aT​,rT​}
  • 计算当前轨迹每个时刻$t$往后的回报${\sum }_{t^{\prime }=t}^T{\gamma }^{t^{\prime }-t_{r_{t^{\prime }}}}$，记为${\psi }_t$
  • 对$\theta$进行更新，$\theta =\theta +\alpha {\sum }_t^T{\psi }_t{\nabla }_{\theta }\log {\pi }_{\theta }(a_t|s_t)$
• end for

注意这里是梯度上升，写成loss的时候应为$\text{loss}=-{\psi }_t\log {\pi }_{\theta }(a_t|s_t)$
REINFORCE 代码实践

import gym
import torch
import torch.nn.functional as F
import numpy as np
import matplotlib.pyplot as plt
from tqdm import tqdm# rl_utils是作者自己写的文件，在github上去下载: 
# https://github.com/boyu-ai/Hands-on-RL/blob/main/rl_utils.py
# kaggle上导入库操作：
from shutil import copyfile
copyfile(src='/kaggle/input/rlutils/rl_utils.py', dst = "../working/rl_utils.py")
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 = devicedef 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 = 0self.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)) # gather用于从张量中提取特定索引处的值。G = self.gamma * G + rewardloss = -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 = 0transition_dict = {'states': [],'actions': [],'next_states': [],'rewards': [],'dones': []}state = env.reset()done = Falsewhile 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_stateepisode_return += rewardreturn_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)

在 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 算法主要的不足。

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