强化学习Actor-Critic算法到底是怎么回事？

咱们有了像Q-learning这么好的算法,为何还要再折腾出一个Actor-Critic算法呢?原来 Actor-Critic 的 Actor 的前生是 Policy Gradients, 这能让它绝不费力地在连续动做中选取合适的动做,而Q-learning 作这件事会瘫痪。那为何不直接用 Policy Gradients呢? 原来Actor Critic中的Critic的前生是 Q-learning 之类以值为基础的学习算法，能进行单步更新，而传统的 Policy Gradients 则是回合更新,这下降了学习效率。

上面的一段话不只解释了为何会有Actor-Critic这么一个算法，同时也告诉了咱们，这个算法具体是怎么作的。既然Actor是一个策略网络（Policy Network）,那么他就须要奖惩信息来进行调节不一样状态下采起各类动做的几率，在传统的Policy Gradient算法中，这种奖惩信息是经过走完一个完整的episode来计算获得的，这致使了学习速率很慢。而既然Critic是一个以值为基础的学习法，那么他能够进行单步更新，计算每一步的奖惩值。那么两者相结合，Actor来选择动做，Critic来告诉Actor它选择的动做是否合适。在这一过程当中，Actor不断迭代，获得每个状态下选择每一动做的合理几率，Critic也不断迭代，不断完善每一个状态下选择每个动做的奖惩值。

一、Actor

1.1 定义Actor输入

在这里，因为咱们的Actor能够进行单次训练，因此咱们的输入只须要是一个状态，一个动做和一个奖励：

self.s = tf.placeholder(tf.float32,[1,n_features],name='state')

self.a = tf.placeholder(tf.int32,None,name='act')

self.td_error = tf.placeholder(tf.float32,None,"td_error")

1.2 Actor的网络定义

Actor的神经网络结构和咱们的Policy Gradient定义的是同样的，是一个双层的全连接神经网络：

with tf.variable_scope('Actor'):

l1 = tf.layers.dense( inputs = self.s, units = 20, activation = tf.nn.relu,

    kernel_initializer = tf.random_normal_initializer(mean=0,stddev=0.1),

    bias_initializer = tf.constant_initializer(0.1),  name = 'l1')

self.acts_prob = tf.layers.dense( inputs = l1, units = n_actions, activation = tf.nn.softmax,

    kernel_initializer = tf.random_normal_initializer(mean=0,stddev=0.1),

    bias_initializer = tf.constant_initializer(0.1), name = 'acts_prob')

​​​​​​​1.3 损失函数

损失函数仍是使用的Policy Gradient中提到过的loss= -log(prob)*vt,只不过这里的vt换成了由Critic计算出的时间差分偏差td_error。

【注意点】这里对于actor网络来讲，td_error越大越好；而对于Critic来讲，则训练的结果时td_error越小越好。这点须要好好体会体会！

with tf.variable_scope('exp_v'):

log_prob = tf.log(self.acts_prob[0,self.a])

self.exp_v = tf.reduce_mean(log_prob * self.td_error)

with tf.variable_scope('train'):

self.train_op =  tf.train.AdamOptimizer(lr).minimize(-self.exp_v)

 

​​​​​​​1.4 Actor训练

Actor的训练只须要将状态，动做以及时间差分值喂给网络就能够。

def learn(self,s,a,td):

s = s[np.newaxis,:]

feed_dict = {self.s:s,self.a:a,self.td_error:td}

_,exp_v = self.sess.run([self.train_op,self.exp_v],feed_dict=feed_dict)

return exp_v

​​​​​​​1.5 选择动做

选择动做和Policy Gradient同样，根据计算出的softmax值来选择动做

def choose_action(self,s):

s = s[np.newaxis,:]

probs = self.sess.run(self.acts_prob,feed_dict={self.s:s})

return np.random.choice(np.arange(probs.shape[1]),p=probs.ravel())

二、critic

2.1 定义Critic输入

Critic要反馈给Actor一个时间差分值，来决定Actor选择动做的好坏，若是时间差分值大的话，说明当前Actor选择的这个动做的惊喜度较高，须要更多的出现来使得时间差分值减少。

考虑时间差分的计算：

TD = r + gamma * f(s') - f(s),这里f(s)表明将s状态输入到Critic神经网络中获得的Q值。

因此Critic的输入也分三个，首先是当前状态，当前的奖励，以及下一个时刻的奖励折现值。为何没有动做A呢？动做A是肯定的呀，是Actor选的呀，对不对！还有为何不是下一时刻的Q值而是下一个时刻的状态，由于咱们已经在计算TD时已经把状态带入到神经网络中获得Q值了。相信你看代码就明白了。

self.s = tf.placeholder(tf.float32,[1,n_features],name='state')

self.v_ = tf.placeholder(tf.float32,[1,1],name='v_next')

self.r = tf.placeholder(tf.float32,None,name='r')

 

​​​​​​​2.2 定义网络结构

同Actor同样，咱们的Critic也是一个双层的神经网络结构。

with tf.variable_scope('Critic'):

l1 = tf.layers.dense( inputs = self.s,  units = 20,  activation = tf.nn.relu,

    kernel_initializer = tf.random_normal_initializer(0,0.1),

    bias_initializer = tf.constant_initializer(0.1),  name = 'l1')

self.v = tf.layers.dense( inputs = l1, units = 1, activation = None, kernel_initializer=tf.random_normal_initializer(0,0.1),bias_initializer = tf.constant_initializer(0.1),  name = 'V')

 

​​​​​​​2.3 定义损失

Critic的损失定义为时间差分值的平方值

with tf.variable_scope('squared_TD_error'):

self.td_error  = self.r + gamma * self.v_ - self.v

self.loss = tf.square(self.td_error)

with tf.variable_scope('train'):

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

 

​​​​​​​2.4 训练Critic

Critic的任务就是告诉Actor当前选择的动做好很差，因此咱们只要训练获得TD并返回给Actor就好：

def learn(self,s,r,s_):

s,s_ = s[np.newaxis,:],s_[np.newaxis,:]

v_ = self.sess.run(self.v,feed_dict = {self.s:s_})

td_error,_ = self.sess.run([self.td_error,self.train_op],  feed_dict={self.s:s,self.v_:v_,self.r:r})

return td_error

 

三、总体模型训练

有了Critic以后，Actor就能够进行单步训练和更新了，因此训练中的关键的代码以下：

while True:  

a = actor.choose_action(s)

  s_,r,done,info = env.step(a)

  td_error = critic.learn(s,r,s_)

  actor.learn(s,a,td_error)

  s = s_