【7】强化学习之策略梯度（Policy Gradient）

什么是强化学习

强化学习（Reinforcement Learning）就是一个Agent从环境中观察来得到输入，然后根据输入来做相应的动作，再根据该动作的有害无害来决定奖励或惩罚。

监督学习 VS. 强化学习

AlphaGo

• 监督学习：就是从看到某个围棋布局就落到相应的位置，看到另外一个就落到那里。但当某个布局人都不知道落在那里的时候，这就有不适用了。说白了就是老师叫你看到这样的盘式下在这个位置，看到另外一个下在哪里。也许机器可以学出一个好的Agent，但学不到一个很厉害的Agent（随机应变）。
  

• 强化学习：机器找一个人与他对弈，若赢了就给予奖励（Reward），输了就惩罚。有时候可能要下上万盘围棋才变得厉害，所以一般是两个Agent相互对弈。可认为是监督学习+强化学习。
  

Chat-bot

• 监督学习：就告诉机器一句话，然后机器就对应说啥话，比如告诉机器“Hello”，你就要说“Hi”。
  在这里插入图片描述

• 强化学习：让机器不断的跟人讲话，讲着讲着人就生气了，这是机器就知道自己某句话将的不对，但没有人告诉他哪句话讲的不好，然后机器就要想办法去挖掘自己哪里讲的不好。
  

我们就让两个机器互相讲话

通过这种方法，我们就生成了许多的对话，但是机器一开始并不知道哪些对话是没问题的。所以我们就要先预定义一些规则来评估机器的对话是否是好的对话

Outline

1. Policy-based Approach：Learning an Actor/Policy

1) Actor=$\pi$(Observation)

该方法类似于Machine Learning 中的找到一个函数，Actor就是一个函数，Observation是Actor函数的input，而Action是函数Actor的Output。

2) The three steps for DL

我们知道深度学习的三个步骤是定义函数，然后评价函数的好坏，最后是选出最好的函数
如果我们的actor是neural network，那我们就是在做DRL。

Step1: Neural network as Actor

找到这个Actor有三个步骤，如果你的Actor是Neural Network，那么你就在做deep reinforcement learning。

• Input of NN: the observation of machine represented as a vector or a matrix，例如在玩下图的游戏中，图像可作为神经网络的输入
• Output of NN: each action corresponds to a neuron in output layer
• NN与表格型学习的方法相比在于，表格型方法不能表示无限多个状态，而我们的NN是给我一个任意的状态（如游戏的画面）就可以输出动作的分布，所以NN是generalization的。
  
  \\[30pt]

Step2: Goodness of Actor

我们怎么评价一个NN的好坏呢，在监督学习中，我们输入一个样本到NN中，将输出标签和输入的样本计算一个loss，若二者很像则loss越小，所以这个NN就越好。因此我们需要找到一组参数（即NN的权值向量）使得loss最小。

那么在强化学习中我们怎么定义一个NN好坏呢？使用总的$R_{\theta }$的期望值来评估。

• 给定一个actor ${\pi }_{\theta }(s)$，其中$\theta$为该actor的参数。

• 采用${\pi }_{\theta }(s)$玩一次游戏得到一幕数据，即$s_1,a_1,r_1,s_2,a_2,r_2,...,s_T,a_T,r_T$。我们将所有的reward加起来得到总的回报$R_{\theta }={\sum }_{t=1}^T{r}_t$， 但是即使是每次的Actor都是相同的，每次的$R_{\theta }$也不一样。有两个原因：1）首先actor（策略）本身就是随机的，当输入相同的状态时可能会采取不同的动作。2）环境的随机性，即采取相同的动作，由于状态不一样所以结果就会不一样。由此可见$R_{\theta }$也是随机的，因此我们用它的期望值来评估，我们希望该期望值越大越好。

• 那么我们怎样计算$R_{\theta }$的期望值${\bar{R}}_{\theta }$呢？
  
  假如我们采用该actor生成了一幕数据为$\tau =s_1,a_1,r_1,s_2,a_2,r_2,...,s_T,a_T,r_T$，计算回报为$R(\tau )={\sum }_{n=1}^N{r}_n$。当玩很多很多幕游戏后，有可能玩的这些多幕的游戏没有列举完所有的幕游戏，但某些幕游戏容易出现，而有些幕游戏则不容易出现，比如我们的这个actor比较智障，它看到子弹会移过去自杀，所以这个actor玩的多次幕游戏自杀的幕游戏占多数。因此当用actor玩游戏时得到的每个$\tau$都有一个出现的几率$P(\tau |\theta )$，这个概率取决于参数$\theta$。
  这时候我们就可以定义${\bar{R}}_{\theta }={\sum }_{\tau }R(\tau )P(\tau |\theta )$，然而我们不可能统计所有可能的幕游戏，所以可以玩N次游戏来近似他，即${\bar{R}}_{\theta }\approx \frac{1}{N}{\sum }_{n=1}^{N}R({\tau }^n)$。

\\[30pt]

Step2: Pick best Actor: 最大化期望值${\bar{R}}_{\theta }$，采用Gadient Ascent

• 找到一个使${\bar{R}}_{\theta }$达到最大的${\theta }^{\ast }$，那么应该怎么做呢？首先随机初始化一个${\theta }^0$，然后使用初始的actor的情况下计算${\bar{R}}_{{\theta }^0}对{\theta }^0$的微分$\nabla {\bar{R}}_{{\theta }^0}$，最后用该微分得到更新的参数${\theta }^1$，重复以上过程。假如我们的参数$\theta$可表示为 θ = { w 1 , w 2 , . . . , b 1 , . . . } \theta=\{w_1,w_2,...,b_1,...\} θ={w1​,w2​,...,b1​,...}，则${\bar{R}}_{\theta }对\theta$的微分$\nabla {\bar{R}}_{\theta }$为：
  $$\nabla {\bar{R}}_{\theta }=\left[\begin{array}{c}\frac{\partial {\bar{R}}_{\theta }}{\partial w_1}\\ \frac{\partial {\bar{R}}_{\theta }}{\partial w_2}\\ ⋮\\ \frac{\partial {\bar{R}}_{\theta }}{\partial b_1}\\ ⋮\end{array}\right]$$
  

• 要对${\bar{R}}_{\theta }$求导数，只需对$P(\tau |\theta )$求导，而$R(\tau )$是依赖于环境的，因此与$\theta$无关。
  

• 下面说明怎么计算$\nabla logP(\tau |\theta )$，首先计算$P(\tau |\theta )$，计算过程如下。其中$p(s_1)和p(r_t,s_{t+1}|s_t,a_t)$和我们的actor是没有关系的，因为它是取决于环境，因此只有$p(a_t|s_t,\theta )$（表示在$s_t$处采取动作$a_t$的概率）与策略${\pi }_{\theta }$有关。

对$P(\tau |\theta )$取对数得到：
$$logP(\tau |\theta )=logp(s_1)+\sum _{t=1}^T\left[logp(a_t|s_t,\theta )+logp(r_t,s_{t+1}|s_t,a_t)\right]$$
再对$logP(\tau |\theta )$对$\theta$求微分得到：
$$\nabla logP(\tau |\theta )=\sum _{t=1}^T\nabla logp(a_t|s_t,\theta )$$
因此我们可以得到$\nabla {\bar{R}}_{\theta }$（下图中红色矩形所示）。注意我们这里是使用每幕的总收益$R({\tau }^n)$，不能用单步的收益$r_t^n$，这会导致只学习单步的动作。

这里需要说明的是，我们为什么要除以$p(a_t^n|s_t^n,\theta )$这一项呢？我们现在采样了多幕数据，假如状态s只出现在幕${\tau }^{13},{\tau }^{15},{\tau }^{17},{\tau }^{33}$中，在${\tau }^{13}$中，状态s处采取动作a得到总的收益为$R({\tau }^{13})=2$。然而在${\tau }^{15},{\tau }^{17},{\tau }^{33}$中，状态s处采取动作b得到的总收益都为1。当做更新的时候，会更偏好于出现次数更多的那些动作，因为我们是对所有幕的所有时间步求和，但这些动作显然并不是那么好（比如在这个例子中）。因此这里除以出现几率比较高的动作，这个操作类似于标准化。

2. Tip 1: Add a baseline

这里有个问题，假如我们的$R({\tau }^n)$总是正的，在理想状态下这是没有问题的，假如在状态s下采取a,b,c三个动作，计算得出a和c的$R({\tau }^n)$比较大，b的${\tau }^n$比较小，那在做完更新之后，选择a和c的概率会增加的多一点，选择b的概率会增加的少一点，虽然概率都会增加，但总体来看b是减少了。但是在实作的时候我们是通过采样幕数据来做更新的，假如现在只采样到动作b和c，而a没有被采样到。因此采样到的动作的几率会增加，未被采样到的动作相对就减小了。
因此我们在$R({\tau }^n)$的基础上减去一个值$b$使得它有正有负，如果我的$R({\tau }^n)$非常好，它好过b，则我们就增加它的概率。若小于b，则减小它的概率。这样就可以避免某个动作没被采样到，使得它的几率变小了。
对于b值的取法，我们可以设置$b=E[R(\tau )]$，即取多幕数据的平均回报。

3. Tip 2: Assign suitable credit

1. 在原来的$\nabla {\bar{R}}_{\theta }$中我们使用的是每幕的总收益$R({\tau }^n)$，但这里做一个替换操作，使用每一个时间步的回报，即$R({\tau }_t^n)={\sum }_{t^{\prime }=t}^{T_n}{r}_{t^{\prime }}^n$。
   
2. 再进一步，我们使用折扣回报${\sum }_{t^{\prime }=t}^{T_n}{\gamma }^{t^{\prime }-t}{r}_{t^{\prime }}^n$，其中$\gamma <1$是折扣因子。使用$A_{\theta }(s_t,a_t)$来表示$R({\tau }^n)-b$，它取决于参数$\theta$。
   

4. Policy Gradient

1. 给定随机初始的actor参数$\theta$，然后拿这个初始的$\theta$去玩N次游戏后，我们就搜集到N个幕游戏，即${\tau }^1,{\tau }^2,...,{\tau }^N$。
2. 根据搜集到的N次数据来更新$\theta$，然后根据新的$\theta$再玩N次游戏，由于是不同的$\theta$因此搜集到的数据不同了。如下图这样循环往复地更新$\theta$，使得$\bar{R}(\theta )$达到最大。

3. 关于上图中右边蓝色框中的$\nabla {\bar{R}}_{\theta }$，你可能对它的求解不太清楚，这里我们知道$R({\tau }^n)$如何计算，但$\nabla log{p}_{\theta }(a_t^n|s_t^n)$如何得到有些困惑。现在假定我们需要处理如下图的一个分类问题，输入一个状态画面，输出三个动作$y_i,i=1,2,3$，这里我们是提前知道该状态画面的标签${\hat{y}}_i,i=1,2,3$，我们的目标为最小化$-{\sum }_{i=1}^3{\hat{y}}_{i}log{y}_i$，对于下面的这个例子来说，实际上是最大化$log{y}_1=logP("left"|s)$，基于此更新参数$\theta$，即$\theta \leftarrow \theta +\eta \nabla logP("left"|s)$
   

4. 回到最初的时候，我们随机初始actor的参数$\theta$，然后拿$\theta$去玩N次游戏后，我们就搜集到N个幕游戏，即${\tau }^1,{\tau }^2,...,{\tau }^n,...,{\tau }^N$。先不考虑$R({\tau }^n)$（下图中用蓝色矩形覆盖），举两个例子：1）在${\tau }^1$中，假如$a_1^1=left$（玩游戏得到的真实标签），我们把$s_1^1$输入到NN中得到三个动作的输出值（NN预测的分类结果），然后根据二者更新NN使得NN越接近动作"left"越好。2）同理，我们希望NN越接近"fire"越好。
   

5. 这里我们看到强化学习中的NN跟以前的NN做的事情是一样的，但不一样的地方是更新公式里面多了一个$R({\tau }^n)$，即在每个时间步前面都乘上了这个时间步对应幕的总收益。那这样做的目的是什么呢？假如现在$R({\tau }^1)=2,R({\tau }^2)=1$，$s_1^1$输入到NN得到输出结果，与真实标签做训练，相当于这样的事情做了两次训练。而对于第二幕数据来说，每个样本做一次训练，因为$R({\tau }^2)=1$。
   

具体算法流程，这种算法叫做 REINFORCE 算法 (Williams, 1992)，这也是最早期使用策略梯度思想的算法，其中${\pi }_{\theta }(a_t|s_t)$与以上的$p_{\theta }(a_t|s_t)$等同。

\\[30pt]

5. PG解决Cartpole-v0

本节以tensorflow给出的强化学习算法示例代码为例子，看看PG应该如何实现。

1）CarPole-v0环境

通过以下代码将CarPole-v0环境渲染出来：

import gym
env = gym.make('CartPole-v0')
env.reset()
for _ in range(1000):
    env.render()
    env.step(env.action_space.sample()) # take a random action
env.close()

显示效果如下：

黑色方块为小车，杆子的一端连接到小车上，由于重力影响杆子会倾斜，当杆子倾斜一定的角度后会倒下。该游戏的任务是控制小车左右移动使得杆子立起来，立起来的时间越长收益越多，即收益与杆子立起来的时间成正比，一旦杆子倒下，游戏结束。

1. CarPole-v0的状态由四个值构成：

序号	环境信息	最小值	最大值
1	小车的位置	$-1.4$	$2.4$
2	小车的速度	$-\infty$	$+\infty$
3	杆子的倾斜角度	$-41.8^{\circ }$	$41.8^{\circ }$
4	杆子顶端的移动速度	$-\infty$	$+\infty$

2. 动作为0和1，分别表示向左和向右移动一步。

2）PG更新框架

        for i_episode in range(num_episodes):
            observation = env.reset()
            for step in range(200):
                # 注意：这里没有用贪婪算法，而是根据pi随机动作，以保证一定的探索性。
                action = RL.choose_action(observation)
                observation_, reward, done, info = env.step(action)
                total_reward += reward
                # 保存数据
                RL.store_transition(observation, action, reward)
                # PG用的是MC，如果到了最终状态
                if done:
                    vt = RL.learn()
                    break
                # 开始新一步
                observation = observation_

下面重点介绍更新框架中的选择动作函数RL.choose_action()，存储数据函数RL.store_transition()，学习函数RL.learn()。

1. RL.choose_action()
   第二行：输入状态s，输出动作值
   第三行：将输出值使用softmax函数作用，结果为所有动作的概率分布
   第四行：根据概率分布随机选择动作

    def choose_action(self, s):
        _logits = self.model(np.array([s], np.float32))     
        _probs = tf.nn.softmax(_logits).numpy()             
        return tl.rein.choice_action_by_probs(_probs.ravel())   #根据策略PI选择动作。

2. RL.store_transition()
   将当前状态s，采取的动作a，以及得到收益r分别存储在三个列表中。

 def store_transition(self, s, a, r):
        self.ep_obs.append(np.array([s], np.float32))
        self.ep_as.append(a)
        self.ep_rs.append(r)

3. RL.learn()

    def learn(self):
        discounted_ep_rs_norm = self._discount_and_norm_rewards()  #1
        with tf.GradientTape() as tape:
            _logits = self.model(np.vstack(self.ep_obs)) 
            neg_log_prob = tf.nn.sparse_softmax_cross_entropy_with_logits \
                          (logits=_logits, labels=np.array(self.ep_as)) #2
            loss = tf.reduce_mean(neg_log_prob * discounted_ep_rs_norm)  #3 
        grad = tape.gradient(loss, self.model.trainable_weights) #4
        self.optimizer.apply_gradients(zip(grad, self.model.trainable_weights))
        
        self.ep_obs, self.ep_as, self.ep_rs = [], [], []  # empty episode data
        return discounted_ep_rs_norm

#1：计算每个时间步的累积折扣回报和标准化

• for循环的作用是计算每个时间步的累积折扣回报，计算公式为：$G_t=R_{t+1}+\gamma R_{t+2}+...={\sum }_{k=0}^{\infty }{\gamma }^k{R}_{t+k+1}$，这样做的目的请参考本文第3节（Tip 2 : Assign suitable credit）。
• 对所有时间步的累积折扣回报进行标准化，即减均值再除以标准差，这样使得G值有正有负，这样做的目的请参考本文第2节（Tip 1: Add a baseline）。

    def _discount_and_norm_rewards(self):
        discounted_ep_rs = np.zeros_like(self.ep_rs)
        running_add = 0
        # 从ep_rs的最后往前，逐个计算G
        for t in reversed(range(0, len(self.ep_rs))):
            running_add = running_add * self.gamma + self.ep_rs[t]
            discounted_ep_rs[t] = running_add
            
        # 我们希望G值有正有负，这样比较容易学习。
        discounted_ep_rs -= np.mean(discounted_ep_rs)
        discounted_ep_rs /= np.std(discounted_ep_rs)
        return discounted_ep_rs

#2：计算NN后输出（动作的概率分布）和真实标签之间的cross entropy。

• _logits为所有状态输入NN后的输出，注意这里的输出没有通过softmax函数作用。但tf.nn.sparse_softmax_cross_entropy_with_logits()函数会将_logits用softmax函数作用。
• labels为真实的分类标签，但tf.nn.sparse_softmax_cross_entropy_with_logits()函数会自动将类别转化成one-hot码。

_logits = self.model(np.vstack(self.ep_obs))
neg_log_prob = tf.nn.sparse_softmax_cross_entropy_with_logits \
                          (logits=_logits, labels=np.array(self.ep_as)) #2

$$\begin{gathered} \frac{1}{N}\sum _{n=1}^N\sum _{t=1}^{T_n}A(s_t,a_t)\nabla logp(a_t^n|s_t^n,\theta ) \\ A(s_t,a_t)=\sum _{t^{\prime }=t}^{T_n}{\gamma }^{t^{\prime }-t}{r}_{t^{\prime }} \end{gathered}$$

• 举个例子，假如_logits = [[-0.00724776, 0.12655543], [-0.06601118, 0.12850013]]，即它是两个状态输入NN的输出结果。labels = [0, 1]，它是这两个状态下采取的动作，第一个状态采取动作0，第二个状态采取动作1，这是actor与环境互动后所采样得到的真实数据。
  三个步骤：
  1）将_logits使用softmax函数作用，结果为：[[0.46659902, 0.53340098], [0.45152491, 0.54847509] ]。
  2）将labels转化成one-hot码，结果为：[[1, 0], [0, 1]]。
  3）计算cross entropy（具体过程请单击此处），结果为：[-1 * log(0.46659902) - 0 * log(0.53340098) , -0 * log(0.45152491) - 1 * log(0.54847509)] = [-1 * log(0.46659902), -1 * log(0.54847509)] = [0.76228502, 0.60061342]。这一步正好与PG中求解$\log p(a_t^n|s_t^n,\theta )$相对应。
  tf.nn.sparse_softmax_cross_entropy_with_logits()的作用就是在完成以上三个步骤。

#3 - #4: 计算梯度

loss = tf.reduce_mean(neg_log_prob * discounted_ep_rs_norm) #3
grad = tape.gradient(loss, self.model.trainable_weights) #4