強化學習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_