强化学习--Policy Gradient

Policy Gradient综述：

　Policy Gradient，通过学习当前环境，直接给出要输出的动作的概率值。

　  Policy Gradient  不是单步更新，只能等玩完一个epoch，再更新参数，采取动作与动作评价是同一个函数，所以是一个on-policy

　　Policy Gradient 需要计算每一个state的期望reward，这个期望reward通过整个epoch的reward_list计算。所以只能等玩完1个epoch才能更新。

数学推导

最大化R,,用梯度下降，需要求R的梯度。

vt的计算

Policy Gradient  不是单步更新，只能等玩完一个epoch，得到每个epoch的observation_list \ action\_list reward_list

学习的时候，根据这三个list更新参数，其中下图公式中的vt 根据reward_list算出来。

vt的计算

Policy Gradient  不是单步更新，只能等玩完一个epoch，得到每个epoch的observation_list \ action\_list reward_list

学习的时候，根据这三个list更新参数，其中下图公式中的vt 根据reward_list算出来。

实现方式

神经网络分类模型，但是在算loss 的时候，logloss需要乘一个系数vt,这个系数与奖励Reward相关，如果采用当前动作，

在接下来的游戏中获得的Reward越大，那么在更新梯度的时候加大当前梯度下降的速度。

算法步骤

vt的计算

Policy Gradient  不是单步更新，只能等玩完一个epoch，得到每个epoch的observation_list \ action\_list reward_list

学习的时候，根据这三个list更新参数，其中下图公式中的vt 根据reward_list算出来。

代码

 """

 This part of code is the reinforcement learning brain, which is a brain of the agent.

 All decisions are made in here.

 Policy Gradient, Reinforcement Learning.

 View more on my tutorial page: https://morvanzhou.github.io/tutorials/

 Using:

 Tensorflow: 1.0

 gym: 0.8.0

 """

 import numpy as np

 import tensorflow as tf

 # reproducible

 np.random.seed(1)

 tf.set_random_seed(1)

 class PolicyGradient:

     def __init__(

             self,

             n_actions,

             n_features,

             learning_rate=0.01,

             reward_decay=0.95,

             output_graph=False,

     ):

         self.n_actions = n_actions

         self.n_features = n_features

         self.lr = learning_rate

         self.gamma = reward_decay

         #每个epoch的observation \ action\ reward

         self.ep_obs, self.ep_as, self.ep_rs = [], [], []

         self._build_net()

         self.sess = tf.Session()

         if output_graph:

             # $ tensorboard --logdir=logs

             # http://0.0.0.0:6006/

             # tf.train.SummaryWriter soon be deprecated, use following

             tf.summary.FileWriter("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")

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

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

         # fc1

         layer = tf.layers.dense(

             inputs=self.tf_obs,

             units=10,

             activation=tf.nn.tanh,  # tanh activation

             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,

             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')  # use softmax to convert to probability

         with tf.name_scope('loss'):

             # to maximize total reward (log_p * R) is to minimize -(log_p * R), and the tf only have minimize(loss)

             neg_log_prob = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=all_act, labels=self.tf_acts)   # this is negative log of chosen action

             # or in this way:

             # 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)  # reward guided loss

         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())  # 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):

         # discount and normalize episode 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 = [], [], []    # empty episode data

         return discounted_ep_rs_norm

     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