强化学习（Reinforcement Learning）之策略梯度(Policy Gradient)的一点点理解以及代码的对应解释

一、策略梯度算法推导以及解释

1.1 背景

设${\pi }_{\theta }(s)$是一个有网络参数$\theta$的actor，然后我们让这个actor和环境（environment）互动或者说去玩一场游戏，在这个游戏中actor会观测环境处于的某种状态s,然后根据这个环境的状态做出一定的动作a（action）来应对环境的变化，从而得到一定的奖励r（reward）

下面是一个使用神经网络搭建的actor，设他的参数是 $\theta$

图片来自：理解策略梯度算法
设 τ = { s 1 , a 1 , r 1 , s 2 , a 2 , r 2 , . . . , s T , a T , r T , E n d } \tau = \{ s_{1}, a_{1}, r_{1},s_{2}, a_{2}, r_{2},...,s_{T}, a_{T}, r_{T},End \} τ={s1​,a1​,r1​,s2​,a2​,r2​,...,sT​,aT​,rT​,End}
对应一场游戏或者和环境互动得到的一个回合（episode）
具体的解释就是： actor在时间t=1时观测到环境的状态$s_1$,为了应对这个环境的状态，actor做出动作$a_1$,从而得到奖励$r_1$,因为我们做出了一个动作$a_1$,此时会引发环境发生变化或者环境自己变化，环境的状态到达$s_2$,actor又会根据这个状态继续做出动作，得到奖励，在这个过程中，actor根据状态做出的动作不一定是对的。对于错的动作，就要给出一个负的奖励，也就从奖励变成了惩罚。游戏会一直玩下去，直到actor灭亡或者环境终止。

1.2 一个小例子

例子：太空侵略者

在这个例子里面actor可以采取的动作有三种：开火(fire)，向右移动(right)，向左移动(left)。也就是遇到任何一个状态，actor可以选择的动作只能从这三个动作里面选择一个。
在上图中actor看到状态：$s_1$，做出的动作是向右移动：$a_1$,因为这里是击杀一个外星人才会有奖励，动作向右移动不会击杀外星人，那么获得的奖励$r_1$就是0，此时环境发生变化，actor看到环境的状态是游戏画面$s_2$,然后actor做出动作$a_2$:开火，因为此时击杀了一个外星人，得到的奖励$r_2$是5.
当所有的外星人被消灭完或者actor被外星人杀死，这个游戏就会结束，也就是一个回合(eposide)结束.

1.3 算法推导以及解释

根据一个回合 τ = { s 1 , a 1 , r 1 , s 2 , a 2 , r 2 , . . . , s T , a T , r T , E n d } \tau = \{ s_{1}, a_{1}, r_{1},s_{2}, a_{2}, r_{2},...,s_{T}, a_{T}, r_{T},End \} τ={s1​,a1​,r1​,s2​,a2​,r2​,...,sT​,aT​,rT​,End}
我们要极大化的目标是一个回合累计的总的奖励也就是优化目标： $$R_{\theta }(\tau )=\sum _{t=1}^T{r}_t\text{\hspace{1em}(1)}$$

下面是很重要的一个点
由于actor所处的环境具有一定的随机性，而且actor根据环境所作出的动作也是具有一定的随机性，我们要优化的目标函数是每个回合总的奖励（total reward）的期望值。

Question 1： 上面所说的环境的随机性是什么意思？

答： 假设把实际生活中的一个人当做一个actor，这个actor生活的环境里面也是有很大的随机性的，比如，突然刮了一场大风，风又突然把一棵大树吹断了，不巧，actor刚好路过，断了的大树突然把actor砸死了，猪脚actor卒，游戏结束，得到的总的奖励（total reward）是0。如果没有遇到上面的随机情况，actor说不定会遇到一个伯乐，然后各种升值加薪，迎娶白富美，走上人生巅峰，然后自然死亡，actor消亡之后，游戏（aposide）结束，获取的总的奖励很大。

你看因为环境的随机性，这个actor可以有两种完全不同的结局。

Question 2： actor本身的随机性又是什么意思？

答： 还拿上面的例子做解释，由于风太大，把树刮断了，大树快要砸着actor，actor由于以前没有经历过这种事情，又因为发生的突然，actor慌了，这种情况下，actor吓懵了，做出了一个在原地不动的动作，然后被大树砸死了，猪脚卒，游戏结束，没有奖励。另外一种情况就是，actor做出朝着一个方向跑的动作，在千钧一发之际，actor疯狂加速，他活了下来。随后遇到了伯乐，各种升职加薪，迎娶白富美，走上人生巅峰。。。。

你看，因为actor自身的随机性，也会有完全不同的结局发生

上面两种不同的结局，获取的一个回合总的奖励（total reward）相差很大，我们使用其中的任何一种来更新actor的网络参数都是不合适的，正式由于这种随机性，可以使用期望值更加精准的来更新actor的参数$\theta$

设$$\stackrel{-}{R_{\theta }}=\sum _{\tau }R(\tau )\ast P(\tau |\theta )\text{\hspace{1em}(2)}$$是所有的eposide（$\tau$）所得到期望值。$R(\tau )={\sum }_{t=1}^T{r}_t$是回合$\tau$的总的奖励，$P(\tau |\theta )$表示在给定actor的网络参数$\theta$，eposide（$\tau$）出现的概率。

上面的公式（2）求期望会遇到一个问题，假如$\tau$ 有无穷多个要怎么办？全部一一列举或者使用求积分来计算根本不靠谱，无法实现而且浪费时间。

Question 3： 如何逼近公式（2）？

答：采样。 比如我们可以得到$N$个eposides，${\tau }_1,{\tau }_1,...,{\tau }_N$,我们就可以得到：
$$\stackrel{-}{R_{\theta }}=\sum _{\tau }R(\tau )\ast P(\tau |\theta )\approx \frac{1}{N}\sum _{n=1}^{N}R({\tau }_n)\text{\hspace{1em}(3)}$$
在公式（3）里面我们假设了每个$\tau$出现的概率是一样的，都是$\frac{1}{N}$。这样就简化了目标函数，并且达到了计算机可以实现的要求。但是，这样的目标函数里面没有参数$\theta$,所以无法更新actor，还要再使用新的方法。

1.4如何优化actor？

首先给粗我们实际中使用的目标函数：注意这里是极大化，实际中还要转化为极小化。加负号就行了
$$R=\frac{1}{N}\sum _{n=1}^N\sum _{t=1}^{T_n}R({\tau }_n)\ast logp(a_t^n|s_t^n,\theta )$$
公式解释：$N$是表示采样的个数，$R({\tau }_n)$是第$n$条样本的所获得累计的奖励，$p(a_t^n|s_t^n,\theta )$表示在状态 $s_t^n$时采取动作 $a_t^n$的概率。
但是这是和理论是有出入的，我么要根据理论内容进行反推出在实际操作中我们使用的目标函数，也就是损失。

下面开始理论的推导：
$$\stackrel{-}{R_{\theta }}=\sum _{\tau }R(\tau )\ast P(\tau |\theta )$$
要优化actor，就要调整actor的网络参数$\theta$，因为我们的目的是要极大化奖励，这里使用的梯度上升，其实因为深度学习框架tensorflow，pytorch等等没有极大化的优化程序，到后面还要将极大化转化为极小化。

因为actor是使用神经网络搭建的，我们来求导优化。
$$▽\stackrel{-}{R_{\theta }}=\sum _{\tau }R(\tau )\ast ▽P(\tau |\theta )\text{\hspace{1em}(4)}$$

由于$R(\tau )$中没有参数$\theta$,因为我们不要求$R(\tau )$是可微的，任意的数值都是可以的。
$$▽\stackrel{-}{R_{\theta }}=\sum _{\tau }R(\tau )\ast ▽P(\tau |\theta )=\sum _{\tau }R(\tau )\ast P(\tau |\theta )\ast \frac{▽P(\tau |\theta )}{P(\tau |\theta )}\text{\hspace{1em}(5)}$$
在公式（4）的右端乘上$P(\tau |\theta )$,然后再除以$P(\tau |\theta )$,就可以得到公式（5）。

继续对公式（5）进行化简，利用的是对数的求导公式$\frac{dln(f(x))}{dx}=\frac{1}{f(x)}\ast \frac{df(x)}{dx}$就可以得到下面的公式
$$▽\stackrel{-}{R_{\theta }}=\sum _{\tau }R(\tau )\ast p(\tau |\theta )\ast ▽logp(\tau |\theta )\text{\hspace{1em}(6)}$$

我们前面说过，要使用采样的方法将理论转化为计算机可以实现的情况。这里我们依然使用采样的方法，来数值逼近公式（6），我们令公式（6）中的$p(\tau |\theta )=\frac{1}{N}$ ，再修改一下求和号,就得到了下面的公式，根据大数定律，
$$▽\stackrel{-}{R_{\theta }}=\frac{1}{N}\sum _{n=1}^{N}R({\tau }_n)\ast ▽logp(\tau |\theta )\text{\hspace{1em}(7)}$$
N表示采样得到的N个样本，公式（7）和公式（3）对比一下就可以看到，公式（3）里面没有actor的参数$\theta$，因此无法更新参数，然而，公式（7）里面就引入了actor的参数$\theta$，可以更新网络的参数。

其实这里还有一个很复杂的问题，那就是如何计算$p(\tau |\theta )$

接下来我们利用链式法则来计算$p(\tau |\theta )$，由于状态之间的转移具有马尔可夫性，也就是下一个状态的发生仅和上一个状态有关，比如状态$s_{n+1}$的发生仅和状态$s_n$有关，和状态$s_n$之前的状态无关。

所以$$\begin{gathered} p(\tau |\theta )=p(s_1,a_1,r_1,s_2,a_2,r_2,...,s_T,a_T,r_T|\theta ) \\ =p(s_1)p(a_1|s_1,\theta )p(r_1,s_2|s_1,a_1)p(a_2|s_2,\theta )p(r_2,s_3|s_2,a_2)...p(a_T|s_t,\theta )p(r_T|s_T,a_T) \\ =p(s_1)\prod _{t=1}^{T}p(a_t|s_t,\theta )p(r_t,s_{t+1}|s_t,a_t)\text{\hspace{1em}(8)} \end{gathered}$$
对公式8两边取自然对数，于是得：
$$logp(\tau |\theta )=logp(s_1)+\sum _{t=1}^{T}logp(a_t|s_t,\theta )+logp(r_t,s_{t+1}|s_t,a_t)\text{\hspace{1em}(9)}$$

对公式9关于$\theta$求导得
$$\begin{gathered} ▽logp(\tau |\theta )=▽(logp(s_1)+\sum _{t=1}^{T}logp(a_t|s_t,\theta )+logp(r_t,s_{t+1}|s_t,a_t)) \\ =\sum _{t=1}^T▽logp(a_t|s_t,\theta )\text{\hspace{1em}(10)} \end{gathered}$$

因为是对$\theta$求导数，
将公式10带入到公式7，于是就有：
$$\begin{gathered} ▽\stackrel{-}{R_{\theta }}=\frac{1}{N}\sum _{n=1}^{N}R({\tau }_n)\ast ▽logp(\tau |\theta ) \\ =\frac{1}{N}\sum _{n=1}^N\sum _{t=1}^{T_n}R({\tau }_n)▽logp(a_t|s_t,\theta )\text{\hspace{1em}(11)} \end{gathered}$$
到这里，根据公式（11）我们就可以反推出我们实际操作中优化的目标函数是：
$$\begin{gathered} \stackrel{-}{R_{\theta }}=\frac{1}{N}\sum _{n=1}^{N}R({\tau }_n)\ast logp(\tau |\theta ) \\ =\frac{1}{N}\sum _{n=1}^N\sum _{t=1}^{T_n}R({\tau }_n)logp(a_t|s_t,\theta ) \end{gathered}$$

还有一非常重要的一点就是：极大化下面的两个目标函数(公式12和13)得到的效果是一样的。
$$\begin{gathered} \stackrel{-}{R_{\theta }}=\sum _{\tau }R(\tau )\ast P(\tau |\theta ) \\ =\sum _{\tau }R(\tau )p(s_1)\prod _{t=1}^{T}p(a_t|s_t,\theta )p(r_t,s_{t+1}|s_t,a_t)\text{\hspace{1em}(12)} \end{gathered}$$
$$\stackrel{-}{R{1}_{\theta }}=\sum _{\tau }R(\tau )\prod _{t=1}^{T}p(a_t|s_t,\theta )\text{\hspace{1em}(13)}$$

这两个目标函数在数值上只是相差了一个和$\theta$无关的常数，因此在使用梯度上升方法时效果是一样的。因为对一个常数求导得到的导数是0。

我们可以看到上面推导出了两种不同形式的目标函数，一个带有对数函数，一个没有。

对于公式13的解释：
如果$R(\tau )$是大于0的，因为我们要极大化奖励，优化的方向就会朝着增大概率$p(a_t|s_t)$进行，如果$R(\tau )$小于0，就会降低$p(a_t|s_t)$，只有这样才可以逐步增大总的奖励。

Question 4：将目标函数转化为对数形式的好处是什么？
答：下面引用李宏毅老师的强化学习课程里面的例子来解释。
$$\begin{gathered} ▽\stackrel{-}{R_{\theta }}=\frac{1}{N}\sum _{n=1}^{N}R({\tau }_n)\ast ▽logp(\tau |\theta ) \\ =\frac{1}{N}\sum _{n=1}^N\sum _{t=1}^{T_n}R({\tau }_n)▽logp(a_t|s_t,\theta ) \end{gathered}$$
在这个公式中，$▽logp(a_t|s_t,\theta )=\frac{▽p(a_t|s_t,\theta )}{p(a_t|s_t,\theta )}$

那么为什么要除去$p(a_t|s_t,\theta )?$
假如在采样得到的样本里面，状态s出现在${\tau }_{13}，{\tau }_{15}，{\tau }_{17}，{\tau }_{33}$中
在${\tau }_{13}$里，当看到状态s，采取动作a，总的奖励$R({\tau }_{13})=2$
在${\tau }_{15}$里，当看到状态s，采取动作b，总的奖励$R({\tau }_{13})=1$
在${\tau }_{17}$里，当看到状态s，采取动作b，总的奖励$R({\tau }_{13})=1$
在${\tau }_{33}$里，当看到状态s，采取动作b，总的奖励$R({\tau }_{13})=1$
从上面的采样的数据可以看到，$p(b|s,\theta )>p(a|s,\theta )$,但是由于看到状态s采取动作a在一个eposide结束时得到的奖励比在看到状态s采取动作b得到的奖励要多，所我们除去$p(a_t|s_t,\theta )$可以起到加权的效果，就像上面的小例子，因为$p(b|s,\theta )>p(a|s,\theta )$,除去$p(b|s,\theta )$和$p(a|s,\theta )$会使$▽logp(a|s,\theta )$相对增大，而$▽logp(b|s,\theta )$相对减小。

二、两个小技巧

2.1、增加一个baseline使得采样得到的$R(\tau )$有正有负。

Question 5：为什么要让$R(\tau )$有正有负？
答：上面我们说过，如果$R(\tau )>0$,$p(a_t|s_t)$会增加，反之若$R(\tau )<0$,$p(a_t|s_t)$会减小。
例子： 假设我们采样得到4个$\tau$,这4个$\tau$均满足$R(\tau )>0$，分别设为1，2，4，5，因为这4个的total reward均大于0，对应的$p(a_t|s_t)$会增加，而那些没有被采样到的策略出现的概率就会减小。比如还有一个$\bar{\tau }$,$R(\bar{\tau })=3$,3>2>1,但是由于没有采样到$\bar{\tau }$而造成出现在$\bar{\tau }$中的策略的概率减小，这是显然不合理的，因此，我们引入一个baseline，对于那些不够显著的$R(\tau )$，可以起到不更新的作用。

比如，我们可以取$b=\frac{1+2+4+5}{4}=3$,将$b$带入到公式11便得到：
$$\begin{gathered} ▽\stackrel{-}{R_{\theta }}=\frac{1}{N}\sum _{n=1}^N(R({\tau }_n)-b)\ast ▽logp(\tau |\theta ) \\ =\frac{1}{N}\sum _{n=1}^N\sum _{t=1}^{T_n}(R({\tau }_n)-b)▽logp(a_t|s_t,\theta )\text{\hspace{1em}(14)} \end{gathered}$$

2.2、引入折扣因子 $\gamma <1$

引入则扣因子之后，目标函数化为
$$▽\stackrel{-}{R_{\theta }}=\frac{1}{N}\sum _{n=1}^N\sum _{t=1}^{T_n}(\sum _{t1=t}^{T_n}{\gamma }^{t1-t}{r}_{t1}^n-b)▽logp(a_t|s_t,\theta )$$

Question 6：为什么引入折扣因子？
答： 折扣因子体现了actor重视当前奖励$r_t$和未来奖励$r_{t+1},...,r_T$的程度，$\gamma$越接近0，说明actor越是不重视未来奖励，越接近1，越重视。

2.3如何将奖励的期望极大化转化为深度学习框架常用的极小化

我们来看下面的公式
$$max\stackrel{-}{R_{\theta }}=\frac{1}{N}\sum _{n=1}^{N}R({\tau }_n)\ast logp({\tau }_n|\theta )$$

因为深度学习框架没有极大化的优化函数，我们在上式两边同时加一个负号“-”将极大化转化为极小化，这一步也将对数函数转化为深度学习框架里面经常使用的交叉熵函数（在下面的程序里面会看到）。

在上式两端加负号“-”就变为下式：
$$min-\stackrel{-}{R_{\theta }}=\frac{1}{N}\sum _{n=1}^{N}R({\tau }_n)\ast (-logp({\tau }_n|\theta ))$$

到了这里，$-logp({\tau }_n|\theta )$这里就已经可以转化为深度学习经常使用的交叉熵函数了。

三、实际案例

import gym
import tensorflow as tf
import numpy as np
import random
from collections import deque



# Hyper Parameters

GAMMA = 0.95 # 折扣因子

LEARNING_RATE=0.01 #学习率



class Policy_Gradient():

    def __init__(self, env):

        # init some parameters

        self.time_step = 0

        self.state_dim = env.observation_space.shape[0]#用一个向量表示一个状态，因此需要获取这个向量的维度
        

        self.action_dim = env.action_space.n#是动作的个数

        self.ep_obs, self.ep_as, self.ep_rs = [], [], []#用来存储一个eposide的所有的状态或者说是观测值，动作，还有奖励

        self.create_softmax_network()



        # Init session

        self.session = tf.InteractiveSession()

        self.session.run(tf.global_variables_initializer())



    def create_softmax_network(self):

        # network weights
		#下面开始搭建actor的神经网络
        W1 = self.weight_variable([self.state_dim, 20])#

        b1 = self.bias_variable([20])

        W2 = self.weight_variable([20, self.action_dim])#输出的最后一个维度是动作的个数，然后依据概率分布选择状态对应的动作
        

        b2 = self.bias_variable([self.action_dim])

        # input layer

        self.state_input = tf.placeholder("float", [None, self.state_dim])#一次可以输入若干个状态

        self.tf_acts = tf.placeholder(tf.int32, [None, ], name="actions_num")

        self.tf_vt = tf.placeholder(tf.float32, [None, ], name="actions_value")

        # hidden layers

        h_layer = tf.nn.relu(tf.matmul(self.state_input, W1) + b1)

        # softmax layer

        self.softmax_input = tf.matmul(h_layer, W2) + b2

        #softmax output

        self.all_act_prob = tf.nn.softmax(self.softmax_input, name='act_prob')

        self.neg_log_prob = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=self.softmax_input,

                                                                      labels=self.tf_acts) #这里就是上面第二节第三个小技巧所说的将对数函数转化为我们经常使用的交叉熵函数

        self.loss = tf.reduce_mean(self.neg_log_prob * self.tf_vt)  # reward guided loss

        self.train_op = tf.train.AdamOptimizer(LEARNING_RATE).minimize(self.loss)



    def weight_variable(self, shape):

        initial = tf.truncated_normal(shape)

        return tf.Variable(initial)



    def bias_variable(self, shape):

        initial = tf.constant(0.01, shape=shape)

        return tf.Variable(initial)


    def choose_action(self, observation):

        prob_weights = self.session.run(self.all_act_prob, feed_dict={self.state_input: observation[np.newaxis, :]})
        
        action = np.random.choice(range(prob_weights.shape[1]), p=prob_weights.ravel())  # select action w.r.t the actions prob

        return action



    def store_transition(self, s, a, r):

        self.ep_obs.append(s)

        self.ep_as.append(a)

        self.ep_rs.append(r)



    def learn(self):

        discounted_ep_rs = np.zeros_like(self.ep_rs)

        running_add = 0

        for t in reversed(range(0, len(self.ep_rs))):

            running_add = running_add * GAMMA + self.ep_rs[t] #折扣因子

            discounted_ep_rs[t] = running_add



        discounted_ep_rs -= np.mean(discounted_ep_rs)

        discounted_ep_rs /= np.std(discounted_ep_rs)



        # train on episode

        self.session.run(self.train_op, feed_dict={

             self.state_input: np.vstack(self.ep_obs),

             self.tf_acts: np.array(self.ep_as),

             self.tf_vt: discounted_ep_rs,
        })



        self.ep_obs, self.ep_as, self.ep_rs = [], [], []    # empty episode data

# Hyper Parameters

ENV_NAME = 'CartPole-v0'

EPISODE = 300 # Episode limitation

STEP = 3000 # Step limitation in an episode

TEST = 10 # The number of experiment test every 100 episode



def main():

  # initialize OpenAI Gym env and dqn agent

  env = gym.make(ENV_NAME)

  agent = Policy_Gradient(env)
  print('action dim is :',agent.action_dim)



  for episode in range(EPISODE):

    # initialize task

    state = env.reset()

    # Train

    for step in range(STEP):
      print('state is :', state)

      action = agent.choose_action(state) # e-greedy action for train 

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

      agent.store_transition(state, action, reward)

      state = next_state

      

      if done:

        #print("stick for ",step, " steps")

        agent.learn()

        break



    # Test every 100 episodes

    if episode % 100 == 0:

      total_reward = 0

      for i in range(TEST):

        state = env.reset()

        for j in range(STEP):

          env.render()

          action = agent.choose_action(state) # direct action for test

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

          total_reward += reward

          if done:

            break

      ave_reward = total_reward/TEST

      print ('episode: ',episode,'Evaluation Average Reward:',ave_reward)
  env.close()



if __name__ == '__main__':

  main()

注：上面的学习方法并没有使用采样，这里是每个eposide都会更新一下，也可以改改代码变成和上面一致的情况。

四、参考文献

1、李宏毅老师的强化学习课程，上面公式推导大多来自他的课程，然后写了一些自己的理解和解释
2、莫烦python
3、理解策略梯度算法
4、刘建平策略梯度（policy gradient）