强化学习之策略梯度(Policy Gradient)

策略梯度（Policy Gradient）的基本思想，就是直接根据状态输出动做或者动做的几率。注意这里和DQN的区别就是DQN输出动做获取的Q值，而Policy Gradient输出的是动做的几率，二者的输出维度是同样的，可是含义不一样。

咱们使用神经网络输入当前的状态，网络就能够输出咱们在这个状态下采起每一个动做的几率，那么网络应该如何训练来实现最终的收敛呢？咱们以前在训练神经网络时，使用最多的方法就是反向传播算法，咱们须要一个偏差函数，经过梯度降低来使咱们的损失最小。但对于强化学习来讲，咱们不知道动做的正确与否，只能经过奖励值来判断这个动做的相对好坏。基于上面的想法，咱们有个很是简单的想法：

若是一个动做获得的reward多，那么咱们就使其出现的几率增长，若是一个动做获得的reward少，咱们就使其出现的几率减少。

根据这个思想，咱们构造以下的损失函数：loss= -log(prob)*vt

上式中log(prob)表示在状态 s 时所选动做为a的几率值，prob<=1，所以log(prob)<0。显然prob这个值越大越好，此时-log(prob)<0而且越小越好。

而vt表明的是当前状态s下采起动做a所能获得的奖励，这是当前的奖励和将来奖励的贴现值的求和。若是在prob很小的状况下, 获得了一个大的结果，也就是大的vt, 那么-log(prob)*vt就更大, 表示更吃惊, (我选了一个不常选的动做, 却发现原来它能获得了一个好的 reward, 那我就得对我此次的参数进行一个大幅修改)。

换句话说，咱们训练的目标就是使得被选择的动做的几率很大，同时使得它能得到的奖励贴现最小，说明此时已经不适合再选取其余动做了。

这就是 -log(prob)*vt的物理意义。下面咱们看看策略梯度的代码应该怎么写。

1.  

一、定义参数

首先，咱们定义了一些模型的参数：

#self.ep_obs,self.ep_as,self.ep_rs分别存储了当前episode的状态，动做和奖励。
self.n_actions = n_actions #动做维度
self.n_features = n_features  #状态维度
self.lr = learning_rate  #学习速率
self.gamma = reward_decay #贴现率
self.ep_obs,self.ep_as,self.ep_rs = [],[],[]  #经验回放缓存

二、定义模型输入

模型的输入包括三部分，分别是观察值，动做和奖励值。

with tf.name_scope('inputs'):
    self.tf_obs = tf.placeholder(tf.float32,[None,self.n_features],name='observation')
    self.tf_acts = tf.placeholder(tf.int32,[None,],name='actions_num')
    self.tf_vt = tf.placeholder(tf.float32,[None,],name='actions_value')

 

三、构建模型

咱们的模型定义了两层的神经网络，网络的输入是每次的状态值，而输出是该状态下采起每一个动做的几率，这些几率在最后会通过一个softmax获得归一化以后的各个动做的几率值向量。

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'
)
all_act = tf.layers.dense(
    inputs = layer,
    units = self.n_actions,
    activation = None,
    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')

 

四、模型的损失

咱们以前介绍过了，模型的损失函数计算公式为：loss= -log(prob)*vt，咱们能够直接使用tf.nn.sparse_softmax_cross_entropy_with_logits 来计算前面一部分，即-log(prob)，不过为了更清楚的显示咱们的计算过程，咱们使用了以下的方式：

with tf.name_scope('loss'):
    neg_log_prob = tf.reduce_sum(-tf.log(self.all_act_prob) * tf.one_hot(indices=self.tf_acts,depth=self.n_actions),axis=1)
    loss = tf.reduce_mean(neg_log_prob * self.tf_vt)

而咱们选择AdamOptimizer优化器进行参数的更新：

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 = np.random.choice(range(prob_weights.shape[1]),p=prob_weights.ravel())
    return action

 

六、存储经验

以前说过，policy gradient是在一个完整的episode结束后才开始训练的，所以，在一个episode结束前，咱们要存储这个episode全部的经验，即状态，动做和奖励。

def store_transition(self,s,a,r):
    self.ep_obs.append(s)
    self.ep_as.append(a)
    self.ep_rs.append(r)

 

七、计算奖励的贴现值

咱们以前存储的奖励是当前状态s采起动做a得到的即时奖励，而当前状态s采起动做a所得到的真实奖励应该是即时奖励加上将来直到episode结束的奖励贴现和。

def _discount_and_norm_rewards(self):
    discounted_ep_rs = np.zeros_like(self.ep_rs)
    running_add = 0
    # reserved 返回的是列表的反序，这样就获得了贴现求和值。
    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
    discounted_ep_rs -= np.mean(discounted_ep_rs)
    discounted_ep_rs /= np.std(discounted_ep_rs)
    return discounted_ep_rs

 

八、模型训练

在定义好上面全部的部件以后，咱们就能够编写模型训练函数了，这里须要注意的是，咱们喂给模型的并非咱们存储的奖励值，而是在通过上一步计算的奖励贴现和。另外，咱们须要在每一次训练以后清空咱们的经验池。

def learn(self):
    discounted_ep_rs_norm = self._discount_and_norm_rewards()
    self.sess.run(self.train_op,feed_dict={
        self.tf_obs:np.vstack(self.ep_obs),
        self.tf_acts:np.array(self.ep_as),
        self.tf_vt:discounted_ep_rs_norm,
    })
    self.ep_obs,self.ep_as,self.ep_rs = [],[],[]
    return discounted_ep_rs_norm

好了，模型相关的代码咱们就介绍完了，如何调用这个模型的代码相信你们一看便明白，咱们就再也不介绍啦。