【强化学习】Policy Gradient算法详解

DeepMind公开课https://sites.google.com/view/deep-rl-bootcamp/lectures
David Silver教程 http://www0.cs.ucl.ac.uk/staff/d.silver/web/Teaching.html
morvanzhou课程https://morvanzhou.github.io/tutorials/machine-learning/reinforcement-learning/
李宏毅教授DRL Lecture https://www.youtube.com/watch?v=z95ZYgPgXOY

【强化学习】Policy Gradient算法详解

1、算法思想

之前的QLearning DQN Sarsa都是通过计算动作得分来决策的，我们是在确定了价值函数的基础上采用某种策略（贪婪-epsilon）的方式去选取动作。经过学习发现Policy Gradient并非我预料中的策略迭代，这种策略梯度的算法归类于策略优化算法中，而不是以迭代为基础的动态规划算法。

Policy Gradient不通过误差反向传播，它通过观测信息选出一个行为直接进行反向传播，当然出人意料的是他并没有误差，而是利用reward奖励直接对选择行为的可能性进行增强和减弱，好的行为会被增加下一次被选中的概率，不好的行为会被减弱下次被选中的概率。
举例如下图所示：输入当前的状态，输出action的概率分布，选择概率最大的一个action作为要执行的操作。
而一个完整的策略 τ 代表的是一整个回合中，对于每个状态下所采取的的动作所构成的序列，而每个回合episode中每个动作的回报和等于一个回合的回报值 $R={\sum }_{t=1}^T{r}_t$
通过以上可得知 π在参数为θ情况下时 τ 发生的概率：
得到了概率之后我们就可以根据采样得到的回报值计算出数学期望，从而得到目标函数，然后用来更新我们的参数 θ

优点：

• 连续的动作空间（或者高维空间）中更加高效；
• 可以实现随机化的策略；
• 某种情况下，价值函数可能比较难以计算，而策略函数较容易。

缺点：

• 通常收敛到局部最优而非全局最优
• 评估一个策略通常低效（这个过程可能慢，但是具有更高的可变性，其中也会出现很多并不有效的尝试，而且方差高

2、公式推导

在本篇文章将会使用参数θ逼近拟合状态值函数$V_{\pi }(s)$和状态动作值函数$Q_{\pi }(s,a)$ 可以理解为我们使用比如神经网络的的function来逼近拟合状态值函数$V_{\pi }(s)$和状态动作值函数$Q_{\pi }(s,a)$ 的分布。
$V_{\theta }(s)\approx V_{\pi }(s)$
$Q_{\theta }(s,a)\approx Q_{\pi }(s,a)$
并且将策略Policy参数化为${\pi }_{\theta }(s,a)=P(a|s,\theta )$，使用model-free的方法，不借助与agent做决策而是将agent丢入不确定的动态环境下，不提供动态环境的信息，让agent自己瞎溜达根据所获得的策略信息更新参数。
通常情况下目标策略有三种方式

• 使用初始价值来判断：$J_1(\theta )=V^{{\pi }_{\theta }}(s1)=E_{{\pi }_{\theta }}[v_1]$
• 使用平均价值：$J_{av}V(\theta )={\sum }_s{d}^{{\pi }_{\theta }}(s)V^{{\pi }_{\theta }}(s)$
• 使用每次time-step的平均奖励：$J_{av}R(\theta )={\sum }_s{d}^{{\pi }_{\theta }}(s){\sum }_a{\pi }_{\theta }(s,a)R_s^a$

我们暂定使用初始值法做目标策略

$J(\theta )=V^{{\pi }_{\theta }}(s1)=E_{{\pi }_{\theta }}[v_1]=E(r_1+\gamma r_2+{\gamma }^2{r}_3+.......|{\pi }_{\theta })$

对该目标函数进行最大化也就是在搜索一组参数向量 $\theta$ ，使得目标函数最大。这实际上做的是改变策略概率而非改变行动轨迹的工作，所以根据套路我们接下来就要使用梯度下降求解${\nabla }_{\theta }J(\theta )$

${\nabla }_{\theta }J(\theta )=\left(\begin{array}{c}\frac{\partial J(\theta )}{\partial {\theta }_1}\\ ⋮\\ \frac{\partial J(\theta )}{\partial {\theta }_n}\end{array}\right)$

在连续策略上选用Gaussian Policy在离散策略下采用softmax Policy

策略梯度定理（The policy gradient theorem）

由于我们是基于model-free的所以无法事先知道动态环境的状态分布，而奖励函数有依赖于动作和状态分布，所以无法进行求导，所以我们需要把奖励采用无偏估计的方法计算出来，首先随机采样然后取均值来估计

假设一个只有一步的MDP，对它使用策略梯度下降。${\pi }_{\theta }(s,a)$表示关于参数θ的函数，映射是$P(a|s,\theta )$。它在状态s所执行一a动作的奖励即为$r=R(s,a)$。那么选择行动a的奖励为${\pi }_{\theta }(s,a)R_{s,a}$，在状态 s 的加权回报为${\sum }_{a\in A}{\pi }_{\theta }(s,a)R(s,a)$，推导如下

$J(\theta )=E_{{\pi }_{\theta }}[R(s,a)]$
$J(\theta )={\sum }_{s\in S}d(s){\sum }_{a\in A}{\pi }_{\theta }(s,a)R(s,a)$

梯度为：
${\nabla }_{\theta }J(\theta )={\nabla }_{\theta }{\sum }_{s\in S}d(s){\sum }_{a\in A}{\pi }_{\theta }(s,a)R(s,a)$
${\nabla }_{\theta }J(\theta )={\sum }_{s\in S}d(s){\sum }_{a\in A}{\nabla }_{\theta }{\pi }_{\theta }(s,a)R(s,a)$

假设策略${\pi }_{\theta }$为零的时候可微，并且已知梯度${\nabla }_{\theta }{\pi }_{\theta }(s,a)$，应用似然比(likelihood ratio)的技巧定义${\nabla }_{\theta }log{\pi }_{\theta }(s,a)$为得分函数（score function）。二者关系如下：
∵${\nabla }_{\theta }{\pi }_{\theta }(s,a)={\pi }_{\theta }(s,a)\frac{{\nabla }_{\theta }{\pi }_{\theta }(s,a)}{{\pi }_{\theta }(s,a)}={\pi }_{\theta }(s,a){\nabla }_{\theta }log{\pi }_{\theta }(s,a)$

∴${\nabla }_{\theta }J(\theta )={\sum }_{s\in S}d(s){\sum }_{a\in A}{\pi }_{\theta }(s,a){\nabla }_{\theta }log{\pi }_{\theta }(s,a)R(s,a)$

根据上文d(s)是策略中的状态分布，$\pi (s,a)$是当前状态的动作概率分布，所以可将策略梯度恢复成期望形式：

${\nabla }_{\theta }J(\theta )=E_{{\pi }_{\theta }}[{\nabla }_{\theta }log{\pi }_{\theta }(s,a)R(s,a)]$

然后再将似然率方式的策略梯度方法应用到多步MDPs上，此时的因为回报值应该为过程中的多步回报值之和，在这里使用$Q_{\pi }(s,a)$代替奖励值R单步(s,a)，对于任意可微的策略梯度如下（策略价值计算公式）：

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

策略梯度定理详细推导过程如下

蒙特卡洛梯度策略强化算法Monte-Carlo Policy Gradient

(不带基数)蒙特卡洛策略梯度通过情节采样，使用随机梯度上升法更新参数，使用策略梯度法，返回$v_t$作为$Q^{{\pi }_{\theta }}(s_t,a_t)的无偏估计$

$\Delta {\theta }_t=\alpha {\nabla }_{\theta }log{\pi }_{\theta }(s_t,a_t)v_t$

所以可得更新公式

${\theta }_{t+1}\leftarrow \theta +\alpha {\nabla }_{\theta }log{\pi }_{\theta }(s_t,a_t)v_t$

算法伪代码如下

带基数的蒙特卡洛梯度策略强化算法ERINFORCE with baseline

在某些情况下可能会出现每一个动作的回报值都是正数但是由于我们是通过采样的方式进行更新的所以这时候可以引入一个基数b
则原式需要修改为
${\nabla }_{\theta }J(\theta )=E_{{\pi }_{\theta }}[{\nabla }_{\theta }log{\pi }_{\theta }(s,a)[Q^{{\pi }_{\theta }}(s,a)-b(s)]]$

3、算法实现

class PolicyGradient:
    def __init__(self, n_actions, n_features, learning_rate=0.01, reward_decay=0.95, output_graph=True):
        self.n_actions = n_actions
        self.n_features = n_features
        self.lr = learning_rate  # 学习率
        self.gamma = reward_decay  # reward 递减率

        self.ep_obs, self.ep_as, self.ep_rs = [], [], []  # 这是我们存储 回合信息的 list

        self._build_net()  # 建立 policy 神经网络

        self.sess = tf.Session()

        if output_graph:  # 是否输出 tensorboard 文件
            # $ tensorboard --logdir=logs
            # http://0.0.0.0:6006/
            # tf.train.SummaryWriter soon be deprecated, use following
            tf.summary.FileWriter(r'D:\logs', self.sess.graph)

        self.sess.run(tf.global_variables_initializer())

    def _build_net(self):
        with tf.name_scope('inputs'):
            self.tf_obs = tf.placeholder(tf.float32, [None, self.n_features], name="observations")  # 接收 observation
            self.tf_acts = tf.placeholder(tf.int32, [None, ], name="actions_num")  # 接收我们在这个回合中选过的 actions
            self.tf_vt = tf.placeholder(tf.float32, [None, ],
                                        name="actions_value")  # 接收每个 state-action 所对应的 value (通过 reward 计算)

        # fc1
        layer = tf.layers.dense(
            inputs=self.tf_obs,
            units=10,  # 输出个数
            activation=tf.nn.tanh,  # 激励函数
            kernel_initializer=tf.random_normal_initializer(mean=0, stddev=0.3),
            bias_initializer=tf.constant_initializer(0.1),
            name='fc1'
        )
        # fc2
        all_act = tf.layers.dense(
            inputs=layer,
            units=self.n_actions,  # 输出个数
            activation=None,  # 之后再加 Softmax
            kernel_initializer=tf.random_normal_initializer(mean=0, stddev=0.3),
            bias_initializer=tf.constant_initializer(0.1),
            name='fc2'
        )

        self.all_act_prob = tf.nn.softmax(all_act, name='act_prob')  # 激励函数 softmax 出概率

        with tf.name_scope('loss'):
            # 最大化 总体 reward (log_p * R) 就是在最小化 -(log_p * R), 而 tf 的功能里只有最小化 loss
            neg_log_prob = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=all_act,
                                                                          labels=self.tf_acts)  # 所选 action 的概率 -log 值
            # 下面的方式是一样的:
            # neg_log_prob = tf.reduce_sum(-tf.log(self.all_act_prob)*tf.one_hot(self.tf_acts, self.n_actions), axis=1)
            loss = tf.reduce_mean(neg_log_prob * self.tf_vt)  # (vt = 本reward + 衰减的未来reward) 引导参数的梯度下降

        with tf.name_scope('train'):
            self.train_op = tf.train.AdamOptimizer(self.lr).minimize(loss)

    def choose_action(self, observation):
        prob_weights = self.sess.run(self.all_act_prob, feed_dict={self.tf_obs: observation[np.newaxis, :]})    # 所有 action 的概率
        action = np.random.choice(range(prob_weights.shape[1]), p=prob_weights.ravel())  # 根据概率来选 action
        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):
        # 衰减, 并标准化这回合的 reward
        discounted_ep_rs_norm = self._discount_and_norm_rewards()  # 功能再面

        # train on episode
        self.sess.run(self.train_op, feed_dict={
            self.tf_obs: np.vstack(self.ep_obs),  # shape=[None, n_obs]
            self.tf_acts: np.array(self.ep_as),  # shape=[None, ]
            self.tf_vt: discounted_ep_rs_norm,  # shape=[None, ]
        })

        self.ep_obs, self.ep_as, self.ep_rs = [], [], []  # 清空回合 data
        return discounted_ep_rs_norm  # 返回这一回合的 state-action value

    def _discount_and_norm_rewards(self):
        # discount episode rewards
        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 * self.gamma + self.ep_rs[t]
            discounted_ep_rs[t] = running_add

        # normalize episode rewards
        discounted_ep_rs -= np.mean(discounted_ep_rs)
        discounted_ep_rs /= np.std(discounted_ep_rs)
        return discounted_ep_rs