在之前的幾篇文章中，我們介紹了基于價值Value的強化學習算法Deep Q Network。有關DQN算法以及各種改進算法的原理和實現，可以參考之前的文章：

實戰深度強化學習DQN-理論和實踐：http://www.lxweimin.com/p/10930c371cac
DQN三大改進(一)-Double DQN：http://www.lxweimin.com/p/fae51b5fe000
DQN三大改進(二)-Prioritised replay：http://www.lxweimin.com/p/db14fdc67d2c
DQN三大改進(三)-Dueling Network：http://www.lxweimin.com/p/b421c85796a2

基于值的強化學習算法的基本思想是根據當前的狀態，計算采取每個動作的價值，然后根據價值貪心的選擇動作。如果我們省略中間的步驟，即直接根據當前的狀態來選擇動作。基于這種思想我們就引出了強化學習中另一類很重要的算法，即策略梯度(Policy Gradient)。之前我們已經介紹過策略梯度的基本思想和實現了，大家可以有選擇的進行預習和復習：

深度強化學習-Policy Gradient基本實現:http://www.lxweimin.com/p/2ccbab48414b

當基于值的強化學習方法和基于策略梯度的強化學習方法相結合，我們就產生了Actor-Critic方法，關于這個方法的介紹，可以參考文章：

深度強化學習-Actor-Critic算法原理和實現：http://www.lxweimin.com/p/25c09ae3d206

但是對于Actor-Critic算法來說，模型涉及到了兩個神經網絡, 而且每次都是在連續狀態中更新參數, 每次參數更新前后都存在相關性, 即模型的訓練數據不再是獨立同分布，這導致神經網絡只能片面的看待問題, 甚至導致神經網絡學不到東西。想想我們之前介紹的DQN是如何解決的這個問題的？就是建立了兩個網絡，一個target網絡，一個eval網絡，同時使用了經驗回放機制！那么如果在Actor-Critic網絡結構中加入這兩個機制，就得到了一種新的強化學習模型：Deep Deterministic Policy Gradient，簡稱DDPG！可以說Actor-Critic + DQN = DDPG，今天，我們就來一探DDPG的究竟！

1、DDPG原理

什么是DDPG呢

什么是DDPG呢？前面我們介紹過了，它是Actor-Critic 和 DQN 算法的結合體。

DDPG的全稱是Deep Deterministic Policy Gradient。

我們首先來看Deep，正如Q-learning加上一個Deep就變成了DQN一樣，這里的Deep即同樣使用DQN中的經驗池和雙網絡結構來促進神經網絡能夠有效學習。

再來看Deterministic，即我們的Actor不再輸出每個動作的概率，而是一個具體的動作，這更有助于我們連續動作空間中進行學習。之前不太理解這個連續動作空間是什么意思，既然policy gradient和dqn都是輸出每個動作的概率和q值，那么我們為什么還要用policy gradient呢？這個連續動作空間的例子可以舉一個么？既然已經誠心誠意的發問了，那么我就班門弄斧回答一下。假如想要通過強化學習得到一個詞的32維詞向量，哇，這個詞向量的動作空間可是無限大的呀，[1,0....0]是一個動作，[0,1...0]是一個動作，如果加上小數，那更是數不過來啦，這時候我們根本不可能去計算每個動作的概率或者q值，我們只能給定狀態即一個單詞，直接輸出一個合適的詞向量。類似于這種情況，DDPG就可以大顯神威了。

DDPG的網絡結構
盜用莫煩老師的一張圖片來形象的表示DDPG的網絡結構，同圖片里一樣，我們稱Actor里面的兩個網絡分別是動作估計網絡和動作現實網絡，我們稱Critic中的兩個網絡分別是狀態現實網絡和狀態估計網絡：

我們采用了類似DQN的雙網絡結構，而且Actor和Critic都有target-net和eval-net。我們需要強調一點的事，我們只需要訓練動作估計網絡和狀態估計網絡的參數，而動作現實網絡和狀態現實網絡的參數是由前面兩個網絡每隔一定的時間復制過去的。

我們先來說說Critic這邊，Critic這邊的學習過程跟DQN類似，我們都知道DQN根據下面的損失函數來進行網絡學習，即現實的Q值和估計的Q值的平方損失：

上面式子中Q(S,A)是根據狀態估計網絡得到的，A是動作估計網絡傳過來的動作。而前面部分R + gamma * maxQ(S',A')是現實的Q值，這里不一樣的是，我們計算現實的Q值，不在使用貪心算法，來選擇動作A',而是動作現實網絡得到這里的A'。總的來說，Critic的狀態估計網絡的訓練還是基于現實的Q值和估計的Q值的平方損失，估計的Q值根據當前的狀態S和動作估計網絡輸出的動作A輸入狀態估計網絡得到，而現實的Q值根據現實的獎勵R，以及將下一時刻的狀態S'和動作現實網絡得到的動作A' 輸入到狀態現實網絡 而得到的Q值的折現值加和得到(這里運用的是貝爾曼方程)。

我們再來說一下Actor這邊，論文中，我們基于下面的式子進行動作估計網絡的參數：

這個式子看上去很嚇人，但是其實理解起來很簡單。假如對同一個狀態，我們輸出了兩個不同的動作a1和a2，從狀態估計網絡得到了兩個反饋的Q值，分別是Q1和Q2，假設Q1>Q2,即采取動作1可以得到更多的獎勵，那么Policy gradient的思想是什么呢，就是增加a1的概率，降低a2的概率，也就是說，Actor想要盡可能的得到更大的Q值。所以我們的Actor的損失可以簡單的理解為得到的反饋Q值越大損失越小，得到的反饋Q值越小損失越大，因此只要對狀態估計網絡返回的Q值取個負號就好啦。是不是很簡單。

DDPG學習中的小trick

與傳統的DQN不同的是，傳統的DQN采用的是一種被稱為'hard'模式的target-net網絡參數更新，即每隔一定的步數就將eval-net中的網絡參數賦值過去，而在DDPG中，采用的是一種'soft'模式的target-net網絡參數更新，即每一步都對target-net網絡中的參數更新一點點，這種參數更新方式經過試驗表明可以大大的提高學習的穩定性。'soft'模式到底是如何更新網絡的？我們可以通過代碼更好的理解。

論文中提到的另一個小trick是對采取的動作增加一定的噪聲：

DDPG的完整流程

介紹了這么多，我們也就能順利理解原文中的DDPG算法的流程：

2、DDPG算法實現

好了，原理介紹的差不多了，我們來看一下代碼的實現。本文的代碼仍然參考的是莫煩老師的代碼。

本文代碼的github地址為：https://github.com/princewen/tensorflow_practice/blob/master/Basic-DDPG/DDPG-update.py

定義超參數
我們首先定義網絡中的超參數，比如經驗池的大小，兩個網絡的學習率等等:

MAX_EPISODES = 200
MAX_EP_STEPS = 200
LR_A = 0.001    # learning rate for actor
LR_C = 0.002    # learning rate for critic
GAMMA = 0.9     # reward discount
TAU = 0.01      # soft replacement
MEMORY_CAPACITY = 10000
BATCH_SIZE = 32

RENDER = False
ENV_NAME = 'Pendulum-v0'

定義網絡輸入
我們需要定義的placeholder包括當前的狀態S，下一時刻的狀態S',以及對應的獎勵R，而動作A由Actor得到，因此不需要再定義：

self.S = tf.placeholder(tf.float32, [None, s_dim], 's')
self.S_ = tf.placeholder(tf.float32, [None, s_dim], 's_')
self.R = tf.placeholder(tf.float32, [None, 1], 'r')

構建兩個網絡
兩個網絡都是兩層全鏈接的神經網絡，Actor輸出一個具體的動作，而Critic網絡輸出一個具體的Q值

def _build_a(self, s, scope, trainable):
    with tf.variable_scope(scope):
        net = tf.layers.dense(s, 30, activation=tf.nn.relu, name='l1', trainable=trainable)
        a = tf.layers.dense(net, self.a_dim, activation=tf.nn.tanh, name='a', trainable=trainable)
        return tf.multiply(a, self.a_bound, name='scaled_a')

def _build_c(self, s, a, scope, trainable):
    with tf.variable_scope(scope):
        n_l1 = 30
        w1_s = tf.get_variable('w1_s', [self.s_dim, n_l1], trainable=trainable)
        w1_a = tf.get_variable('w1_a', [self.a_dim, n_l1], trainable=trainable)
        b1 = tf.get_variable('b1', [1, n_l1], trainable=trainable)
        net = tf.nn.relu(tf.matmul(s, w1_s) + tf.matmul(a, w1_a) + b1)
        return tf.layers.dense(net, 1, trainable=trainable)  # Q(s,a)

soft模式參數更新
可以看到，我們這里進行的是soft模式的參數更新，每次在原來target-net參數的基礎上，改變一丟丟，增加一點點eval-net的參數信息。

# networks parameters
self.ae_params = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='Actor/eval')
self.at_params = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='Actor/target')
self.ce_params = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='Critic/eval')
self.ct_params = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='Critic/target')

# target net replacement
self.soft_replace = [[tf.assign(ta, (1 - TAU) * ta + TAU * ea), tf.assign(tc, (1 - TAU) * tc + TAU * ec)]
                     for ta, ea, tc, ec in zip(self.at_params, self.ae_params, self.ct_params, self.ce_params)]

定義兩個網絡的損失
關于兩個網絡的損失，我們之前已經詳細介紹過了，這里只是對剛才思路的一個代碼實現。

q_target = self.R + GAMMA * q_
# in the feed_dic for the td_error, the self.a should change to actions in memory
td_error = tf.losses.mean_squared_error(labels=q_target, predictions=q)
self.ctrain = tf.train.AdamOptimizer(LR_C).minimize(td_error, var_list=self.ce_params)

a_loss = - tf.reduce_mean(q)    # maximize the q
self.atrain = tf.train.AdamOptimizer(LR_A).minimize(a_loss, var_list=self.ae_params)

學習
我們首先要從經驗池中取出一個batch的數據，然后訓練我們的Actor和Critic

def learn(self):
    # soft target replacement
    self.sess.run(self.soft_replace)

    indices = np.random.choice(MEMORY_CAPACITY, size=BATCH_SIZE)
    bt = self.memory[indices, :]
    bs = bt[:, :self.s_dim]
    ba = bt[:, self.s_dim: self.s_dim + self.a_dim]
    br = bt[:, -self.s_dim - 1: -self.s_dim]
    bs_ = bt[:, -self.s_dim:]

    self.sess.run(self.atrain, {self.S: bs})
    self.sess.run(self.ctrain, {self.S: bs, self.a: ba, self.R: br, self.S_: bs_})

存儲經驗

def store_transition(self, s, a, r, s_):
    transition = np.hstack((s, a, [r], s_))
    index = self.pointer % MEMORY_CAPACITY  # replace the old memory with new memory
    self.memory[index, :] = transition
    self.pointer += 1

好啦，我們這里就簡單介紹一下代碼中的核心部分，其余的代碼大家可以參照github進行學習，祝大家清明節快樂，玩得開心，學得開心！

參考文獻：

1、https://morvanzhou.github.io/tutorials/machine-learning/reinforcement-learning/6-2-A-DDPG/
2、論文：https://arxiv.org/abs/1509.02971