策略梯度算法

第九章 策略梯度算法

9.1 简介

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

9.2 策略梯度

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

$$J\left(\theta \right)=E_{s_0}\left[V^{{\pi }_{\theta }}\left(s_0\right)\right]$$

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

第3章讲解过策略$$\pi$$下的状态访问分布，在此用$${\nu }^{\pi }$$表示。然后我们对目标函数求梯度，可以得到如下式子，更详细的推导过程将在9.6解给出。
$${\nabla }_{\theta }J\left(\theta \right)\propto \underset{s\in S}{\Sigma }{\nu }^{{\pi }_{\theta }}\left(s\right)\underset{a\in A}{\Sigma }{Q}^{{\pi }_{\theta }}\left(s,a\right){\nabla }_{\theta }{\pi }_{\theta }\left(a|s\right)$$

$$=\underset{s\in S}{\Sigma }{\nu }^{{\pi }_{\theta }}\left(s\right)\underset{a\in A}{\Sigma }{\pi }_{\theta }\left(a|s\right)Q^{{\pi }_{\theta }}\left(s,a\right)\frac{{\nabla }_{\theta }{\pi }_{\theta }\left(a|s\right)}{{\pi }_{\theta }\left(a|s\right)}$$

$$=E_{{\pi }_{\theta }}\left[Q^{{\pi }_{\theta }}\left(s,a\right){\nabla }_{\theta }\log {\pi }_{\theta }\left(a|s\right)\right]$$

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

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

$${\nabla }_{\theta }J\left(\theta \right)=E_{{\pi }_{\theta }}\left[\underset{t=0}{\stackrel{T}{\Sigma }}\left(\underset{t^{\prime }=t}{\stackrel{T}{\Sigma }}{\gamma }^{t^{\prime }-t}{r}_{t^{\prime }}\right){\nabla }_{\theta }\log {\pi }_{\theta }\left(a_t|s_t\right)\right]$$

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

9.3 REINFORCE

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

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

这便是REINFORCE算法的全部流程。

9.4 REINFORCE 代码实践

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

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

下面这段代码是神经网络的那一部分 ，和基于价值的算法其实是大差不差的，最大的不同就是激活函数，使用的是softmax函数

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)

再定义RENIFORCE算法。在函数take_action()函数中，通过动作概率分布对离散的动作进行采样。在更新过程中，按照算法将损失函数写为策略回报的负数，即$$-{\Sigma }_t^T{\psi }_t{\nabla }_{\theta }\log {\pi }_{\theta }(a_t|s_t)$$，对$$\theta$$求导后就可以通过梯度下降来更新策略。

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()  # 梯度下降
        
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)
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()

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]

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

9.5 小结

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