深度Q學習原理及相關(guān)實例

• • 8. 深度Q學習
  • • 8.1 經(jīng)驗回放
    • 8.2 目標網(wǎng)絡(luò)
    • 8.3 相關(guān)算法
    • 8.4 訓練算法
    • 8.5 深度Q學習實例
    • • 8.5.1 主程序
      • • 程序注釋
      • 8.5.2 DQN模型構(gòu)建程序
      • • 程序注釋
      • 8.5.3 程序測試
    • 8.6 雙重深度Q網(wǎng)絡(luò)
    • 8.7 對偶深度Q網(wǎng)絡(luò)

8. 深度Q學習

深度Q學習將深度學習和強化學習相結(jié)合，是第一個深度強化學習算法。深度Q學習的核心就是用一個人工神經(jīng)網(wǎng)絡(luò)$q(s,a;\theta ),s\in \mathcal{S},a\in \mathcal{A}$來代替動作價值函數(shù)。其中$\theta$為神經(jīng)網(wǎng)絡(luò)權(quán)重,在前面文章中,也使用過$\text{w}$。由于神經(jīng)網(wǎng)絡(luò)具有強大的表達能力，能夠自動尋找特征，所以采用神經(jīng)網(wǎng)絡(luò)有潛力比傳統(tǒng)人工特征強大得多。最近基于深度Q網(wǎng)絡(luò)的深度強化學習算法有了重大的進展，在目前學術(shù)界有非常大的影響力。當同時出現(xiàn)異策、自益和函數(shù)近似時，無法保證收斂性，會出現(xiàn)訓練不穩(wěn)定或訓練困難等問題。針對出現(xiàn)的各種問題，研究人員主要從以下兩方面進行了改進。

• 經(jīng)驗回放（experience replay）：將經(jīng)驗（即歷史的狀態(tài)、動作、獎勵等）存儲起來，再在存儲的經(jīng)驗中按一定的規(guī)則采樣。
• 目標網(wǎng)絡(luò)（target network）：修改網(wǎng)絡(luò)的更新方式，例如不把剛學習到的網(wǎng)絡(luò)權(quán)重馬上用于后續(xù)的自益過程。本節(jié)后續(xù)內(nèi)容將從這兩條主線出發(fā)，介紹基于深度Q網(wǎng)絡(luò)的強化學習算法。

8.1 經(jīng)驗回放

V. Mnih 等在 2013 年 發(fā) 表 文 章 《Playing Atari with deep reinforcement leaming》，提出了基于經(jīng)驗回放的深度Q網(wǎng)絡(luò)，標志著深度Q網(wǎng)絡(luò)的誕生，也標志著深度強化學習的誕生¹。

采用批處理的模式能夠提供穩(wěn)定性。經(jīng)驗回放就是一種讓經(jīng)驗的概率分布變得穩(wěn)定的技術(shù)，它能提高訓練的穩(wěn)定性。
經(jīng)驗回放主要有“存儲”和 “采樣回放”兩大關(guān)鍵步驟。其相關(guān)算法在之后會介紹, 現(xiàn)在主要來看其特征。

• 存儲：將軌跡以$(S_t,A_t,R_{t+1},S_{t+1})$ 等形式存儲起來；
• 采樣回放：使用某種規(guī)則從存儲的$(S_t,A_t,R_{t+1},S_{t+1})$ 中隨機取出一條或多條經(jīng)驗。

經(jīng)驗回放有以下好處。

• 在訓練Q網(wǎng)絡(luò)時，可以消除數(shù)據(jù)的關(guān)聯(lián)，使得數(shù)據(jù)更像是獨立同分布的（獨立同分布是很多有監(jiān)督學習的證明條件）。這樣可以減小參數(shù)更新的方差，加快收斂。
• 能夠重復使用經(jīng)驗，對于數(shù)據(jù)獲取困難的情況尤其有用。從存儲的角度，經(jīng)驗回放可以分為集中式回放和分布式回放。

回放可以分為以下幾種,

• 集中式回放：智能體在一個環(huán)境中運行，把經(jīng)驗統(tǒng)一存儲在經(jīng)驗池中。
• 分布式回放：智能體的多份拷貝(worker)同時在多個環(huán)境中運行，并將經(jīng)驗統(tǒng)一存 儲于經(jīng)驗池中。由于多個智能體拷貝同時生成經(jīng)驗，所以能夠在使用更多資源的同
  時更快地收集經(jīng)驗。從采樣的角度，經(jīng)驗回放可以分為均勻回放和優(yōu)先回放。
• 均勻回放：等概率從經(jīng)驗集中取經(jīng)驗，并且用取得的經(jīng)驗來更新最優(yōu)價值函數(shù)。
• 優(yōu)先回放(PrioritizedExperienceReplay, PER): 為經(jīng)驗池里的每個經(jīng)驗指定一個優(yōu)
  先級，在選取經(jīng)驗時更傾向于選擇優(yōu)先級高的經(jīng)驗。

T. Schaul等 于 2016年發(fā)表文章《Prioritized experience replay》，提出了優(yōu)先回放。優(yōu)先回放的基本思想是為經(jīng)驗池里的經(jīng)驗指定一個優(yōu)先級，在選取經(jīng)驗時更傾向于選擇優(yōu)先級高的經(jīng)驗。一般的做法是，如果某個經(jīng)驗(例如經(jīng)驗$i$)的優(yōu)先級為$p_i$，那么選取該經(jīng)驗的概率為
$$p_i=\frac{p_i}{{\sum }_k{p}_k}$$

經(jīng)驗值有許多不同的選取方法，最常見的選取方法有成比例優(yōu)先和基于排序優(yōu)先。

• 成比例優(yōu)先(proportional priority):第$i$個經(jīng)驗的優(yōu)先級為
  $$p_i=({\delta }_i+\epsilon {)}^{\alpha }$$
  其中${\delta }_i$是時序差分誤差，$\epsilon$是預先選擇的一個小正數(shù)，$\alpha$是正參數(shù)。
• 基于排序優(yōu)先(rank-basedpriority):第$i$個經(jīng)驗的優(yōu)先級為
  $$p_i=(\frac{1}{{\text{rank}}_i}{)}^{\alpha }$$
  其中${\text{rank}}_i$是第$i$個經(jīng)驗從大到小排序的排名, 排名從1開始。

經(jīng)驗回放也不是完全沒有缺點。例如，它也會導致回合更新和多步學習算法無法使用。一般情況下，如果我們將經(jīng)驗回放用于Q學習，就規(guī)避了這個缺點。

8.2 目標網(wǎng)絡(luò)

對于基于自益的Q學習，其回報的估計和動作價值的估計都和權(quán)重$\theta$有關(guān)。當權(quán)重值變化時，回報的估計和動作價值的估計都會變化。在學習的過程中，動作價值試圖追逐一個變化的回報，也容易出現(xiàn)不穩(wěn)定的情況?？梢允褂弥敖榻B的半梯度下降的算法來解決這個問題。在半梯度下降中，在更新價值參數(shù)$\theta$時，不對基于自益得到的回報估計$U_t$求梯度。其中一種阻止對$U_t$求梯度的方法就是將價值參數(shù)復制一份得到${\theta }_{\text{target}}$， 在計算$U_t$時用${\theta }_{\text{target}}$目標計算。

基于這一方法，V. Mnih等 在 2015年發(fā)表了論文《Human-level control through deep reinforcement learning》提出了目標網(wǎng)絡(luò)（target network） 這一概念。 目標網(wǎng)絡(luò)是在原有的神經(jīng)網(wǎng)絡(luò)之外再搭建一份結(jié)構(gòu)完全相同的網(wǎng)絡(luò)。原先就有的神經(jīng)網(wǎng)絡(luò)稱為評估網(wǎng)絡(luò)（ evaluation network）。在學習的過程中，使用目標網(wǎng)絡(luò)來進行自益得到回報的評估值，作 為學習的目標。在權(quán)重更新的過程中，只更新評估網(wǎng)絡(luò)的權(quán)重，而不更新目標網(wǎng)絡(luò)的權(quán)重。這樣，更新權(quán)重時針對的目標不會在每次迭代都變化，是一個固定的目標。在完成一定次數(shù)的更新后，再將評估網(wǎng)絡(luò)的權(quán)重值賦給目標網(wǎng)絡(luò)，進而進行下一批更新。這樣，目標網(wǎng)絡(luò)也能得到更新。由于在目標網(wǎng)絡(luò)沒有變化的一段時間內(nèi)回報的估計是相對固定的，目標網(wǎng)絡(luò)的引入增加了學習的穩(wěn)定性。所以，目標網(wǎng)絡(luò)目前已經(jīng)成為深度Q學習的主流做法。

8.3 相關(guān)算法

現(xiàn)在我們考慮使用深度Q學習算法來訓練智能體玩游戲²。

在每一個時間步驟中，智能體從游戲動作集$\mathcal{A}=1,...K$中選擇一個動作。該動作被傳遞給模擬器并修改其內(nèi)部狀態(tài)和游戲分數(shù)。在一般情況下，環(huán)境可能是隨機的。仿真器的內(nèi)部狀態(tài)不被智能體觀察到，相反，智能體觀察到一個來自仿真器的圖像$x_t\in {\mathbb{R}}^d$，這是一個代表當前屏幕的像素值的向量。此外，它還會收到代表游戲分數(shù)變化的獎勵 $r_t$。需要注意的是，一般情況下，游戲得分可能取決于之前的整個動作和觀察序列；關(guān)于一個動作的反饋可能只有在經(jīng)過數(shù)千次的時間步長之后才會收到。

由于智能體只能觀察當前屏幕，任務(wù)是部分觀察，許多模擬器狀態(tài)在感知上是異構(gòu)的（即不可能只從當前屏幕$x_t$中完全了解當前情況）。因此，動作和觀察的序列$s_t=x_1,a_1,x_2,...,a_{t?1},x_t$ 被輸入到算法中，然后算法根據(jù)這些序列學習游戲策略。仿真器中的所有序列都被假定為在有限的時間步長內(nèi)終止。這個形式化的過程產(chǎn)生了一個大而有限的馬爾科夫決策過程(MDP)，在這個過程中，每個序列都是一個獨立的狀態(tài)。因此，我們可以將標準的強化學習方法應用于MDP，只需將完整序列$s_t$作為時間$t$的狀態(tài)表示即可。

智能體的任務(wù)是在模擬器中選擇最佳的動作最大化未來的損失.我們做一個標準的假設(shè),對未來的每一步回報采用一個折扣因子$\gamma$($\gamma$從始至終設(shè)置為0.99),然后定義了在時間$t$上經(jīng)過折扣后的回報$R_t={\sum }_{t^{\prime }=t}^T{\gamma }^{t^{\prime }?t}{r}_{t^{\prime }}$,其中$T$為最終停止的時間步。我們定義最佳動作價值函數(shù)$Q^{?}(s,a)$作為遵循任何策略所能獲得的最大預期收益。在經(jīng)過一些狀態(tài)$s$和采取一些動作$a$后,$Q^{?}(s,a)={\max }_{\pi }\mathbb{E}[R_t|s_t=s,a_t=a,\pi ]$,其中$\pi$作為在狀態(tài)$s$采取的動作$a$的映射,即策略。

最優(yōu)行為價值函數(shù)遵循一個重要的恒等式，這個恒等式被稱為貝爾曼方程(Bellman equation)。這基于以下直覺:如果狀態(tài)$s^{\prime }$在下一個時間步的最優(yōu)值$Q^{?}(s^{\prime },a^{\prime })$對于所有可能的行動$a^{\prime }$都已知，那么最優(yōu)策略就是選擇使期望值$r+\gamma Q^{?}(s^{\prime },a^{\prime })$最大化的行動$a^{\prime }$:
$$Q^{?}(s,a)={\mathbb{E}}_{s^{\prime }}[r+\gamma \underset{a^{\prime }}{\max }{Q}^{?}(s^{\prime },a^{\prime })|s,a]$$

許多強化學習算法背后的基本思想是通過使用貝爾曼方程作為迭代更新來估計動作價值函數(shù)，$Q_{i+1}(s,a)={\mathbb{E}}_{s^{\prime }}[r+\gamma {\max }_{a^{\prime }}{Q}_i(s^{\prime },a^{\prime })|s,a]$。這些價值迭代算法都收斂于最優(yōu)動作價值函數(shù),當$i\to \infty$時$Q_i\to Q^{?}$。在實踐中，這種基本的方法是不切實際的，因為動作-價值函數(shù)是對每個狀態(tài)分別估計的，沒有任何泛化。相反，通常使用函數(shù)逼近器來估計動作價值函數(shù)$Q(s,a;\theta )\approx Q^{?}(s,a)$。在強化學習中這是典型的線性函數(shù)逼近器，但是有時用非線性函數(shù)逼近器代替，如神經(jīng)網(wǎng)絡(luò)。我們把帶有權(quán)值$\theta$的神經(jīng)網(wǎng)絡(luò)函數(shù)逼近器稱為Q網(wǎng)絡(luò)。Q網(wǎng)絡(luò)可以通過在迭代$i$中調(diào)整參數(shù)${\theta }_i$來訓練減少貝爾曼方程中的均方誤差, 其中最佳目標值$r+\gamma {\max }_{a^{\prime }}{Q}^{?}(s^{\prime },a^{\prime })$被替代為近似目標值$y=r+\gamma {\max }_{a^{\prime }}Q(s^{\prime },a^{\prime };{\theta }_i^{?})$,其使用先前的一些迭代中的參數(shù)${\theta }_i^{?}$。這就產(chǎn)生了一個損失函數(shù)$L_i({\theta }_i)$的序列，它在每次迭代$i$時發(fā)生變化，

$$\begin{array}{rl}{L}_i({\theta }_i)& ={\mathbb{E}}_{s,a,r}[({\mathrm{E}}_{s^{\prime }}[y|s,a]?Q(s,a;{\theta }_i){)}^2]\\ & ={\mathbb{E}}_{s,a,r,s^{\prime }}[(y?Q(s,a;{\theta }_i){)}^2]+{\mathrm{E}}_{s,a,r}[{\mathrm{V}}_{s^{\prime }}[y]]\end{array}$$

請注意，目標取決于網(wǎng)絡(luò)權(quán)重；這與用于監(jiān)督學習的目標不同，后者在學習開始前是固定的。在優(yōu)化的每一個階段，我們在優(yōu)化第$i$個損失函數(shù)$L_i({\theta }_i)$時，保持上一次迭代的參數(shù)${\theta }_i^{?}$固定，從而產(chǎn)生一系列定義明確的優(yōu)化問題。最后一項是目標的方差，它不依賴于我們當前優(yōu)化的參數(shù)${\theta }_i$，因此可以忽略。將損失函數(shù)相對于權(quán)重進行微分，我們得出以下梯度:

$${?}_{{\theta }_i}L({\theta }_i)={\mathbb{E}}_{s,a,r,s^{\prime }}[(r+\gamma \underset{a^{\prime }}{\max }Q(s^{\prime },a^{\prime };{\theta }_i^{?})?Q(s,a;{\theta }_i)){?}_{{\theta }_i}Q(s,a;{\theta }_i))]$$

與其計算上述梯度中的全部期望值，不如通過隨機梯度下降來優(yōu)化損失函數(shù)，這通常是計算上的便利。在這個框架中，通過在每一個時間步長后更新權(quán)重，使用單樣本替換期望值，并設(shè)置${\theta }_i^{?}={\theta }_{i?1}$，可以恢復熟悉的Q-learning算法。

需要注意的是，這個算法是無模型的：它直接使用仿真器的樣本來解決強化學習任務(wù)，而不需要明確地估計獎賞和過渡動態(tài)$P(r,s^{\prime }|s,a)$.它也是off-policy：它學習貪婪的策略$a=\underset{a^{\prime }}{\mathrm{argmax}}Q(s,a^{\prime };\theta )$，以確保充分探索狀態(tài)空間。在實際工作中，行為分布往往由$\epsilon$-greedy策略選擇，遵循概率$1?\epsilon$貪婪策略，選擇概率$\epsilon$的隨機行動。

8.4 訓練算法

訓練深度Q-網(wǎng)絡(luò)的完整算法在下圖所示的算法1中提出。智能體根據(jù)基于Q表的$\epsilon$-貪婪策略選擇和執(zhí)行動作。 由于使用任意長度的歷史作為神經(jīng)網(wǎng)絡(luò)的輸入可能是困難的，Q函數(shù)因此工作在由上述函數(shù)$?$產(chǎn)生的固定長度的歷史表征上。該算法以兩種方式修改了標準的在線Q-learning，使其適用于訓練大型神經(jīng)網(wǎng)絡(luò)而不產(chǎn)生分歧。

首先，這里使用了經(jīng)驗回放，我們將智能體在每個時間步的經(jīng)驗$e_t=(s_t，a_t，r_t，s_{t+1})$存儲在一個數(shù)據(jù)集$D_t=e_1，...,e_t$中，將許多情節(jié)(其中一個情節(jié)的結(jié)束發(fā)生在達到終端狀態(tài)時)匯集到重放存儲器中。在算法的內(nèi)循環(huán)過程中，我們對從存儲樣本池中隨機抽取的經(jīng)驗樣本$(s,a,r,s^{\prime })～U(D)$進行Q-learning更新，或稱minibatch更新。這種方法比標準的在線Q-learning有幾個優(yōu)勢。

• 第一，每一步的經(jīng)驗都有可能被用于許多權(quán)重更新，這使得數(shù)據(jù)效率更高。
• 第二，直接從連續(xù)的樣本中學習是低效的，因為樣本之間有很強的相關(guān)性；隨機化樣本可以打破這些相關(guān)性，從而降低更新的方差。
• 第三，在對策略進行學習時，當前的參數(shù)決定了參數(shù)訓練的下一個數(shù)據(jù)樣本。例如，如果最大化動作是向左移動，那么訓練樣本將以左手邊的樣本為主；如果最大化動作隨后切換到右邊，那么訓練分布也將切換。

很容易看出，不需要的反饋循環(huán)可能會出現(xiàn)，參數(shù)可能會被卡在一個糟糕的局部最小值中，甚至是災難性的偏離。通過使用經(jīng)驗重放，行為分布是對其以前的許多狀態(tài)進行平均，平滑學習，避免參數(shù)的振蕩或發(fā)散。需要注意的是，通過經(jīng)驗重放學習時，需要進行off-policy學習（因為我們當前的參數(shù)與用于生成樣本的參數(shù)不同），這也是選擇Q-learning的動機。

在實踐中，算法只在重放存儲器中存儲最后的$N$個經(jīng)驗元組，并在執(zhí)行更新時從$D$中隨機均勻取樣。這種方法在某些方面是有局限性的，因為內(nèi)存緩沖區(qū)并不能區(qū)分重要的轉(zhuǎn)折，而且由于內(nèi)存大小$N$是有限的，所以總是用最近的轉(zhuǎn)折來覆蓋。同樣，均勻采樣對重放內(nèi)存中的所有轉(zhuǎn)折給予同等的重要性。

對在線Q-learning的第二個修改旨在進一步提高方法與神經(jīng)網(wǎng)絡(luò)的穩(wěn)定性，就是在Q-learning更新中使用一個單獨的網(wǎng)絡(luò)來生成目標$y_j$,即,建立目標網(wǎng)絡(luò)。更準確的說，每一次C更新，我們都會克隆網(wǎng)絡(luò)Q，得到一個目標網(wǎng)絡(luò)$\hat{Q}$，并使用$\hat{Q}$來生成Q-learning目標$y_j$，用于后續(xù)C更新Q。與標準的在線Q-learning相比，這種修改使得算法更加穩(wěn)定，在標準的在線Q-learning中，增加$Q(s_t,a_t)$的更新往往也會增加所有$a$的$Q(s_{t+1},a)$，因此也會增加目標$y_j$，可能會導致策略的振蕩或分歧。使用較舊的參數(shù)集生成目標，在對Q進行更新和更新影響目標$y_j$之間增加了一個延遲，使得分歧或振蕩的可能性大大降低。

將更新$r+\gamma {\max }_{a^{\prime }}Q(s^{\prime },a^{\prime };{\theta }_i^{?})?Q(s,a;,{\theta }_i)$中的誤差項約束為-1和1之間是很有幫助的.因為絕對值損失函數(shù)$|x|$對x的所有負值都有-1的導數(shù)，對x的所有正值都有1的導數(shù)，所以將平方誤差剪裁為$?1$和$1$之間相當于對$(?1,1)$區(qū)間外的誤差使用絕對值損失函數(shù).這種形式的誤差剪裁進一步提高了算法的穩(wěn)定性.

8.5 深度Q學習實例

在這個實例里我們采用"LunarLander-v2"環(huán)境。

LunarLander-v2 著陸臺總是在坐標（0,0）處。坐標是狀態(tài)向量的前兩個數(shù)字。從屏幕頂部移動到著陸臺并以零速度降落的獎勵大約是100…140點。如果著陸器遠離著陸臺，就會失去獎勵。如果著陸器墜毀或靜止，則事件結(jié)束，獲得額外的-100或+100分。每條腿的地面接觸是+10。發(fā)射主引擎每格為-0.3分。解決了就是+200分。可以在起落架外降落。燃料是無限的，所以智能體可以學習飛行，然后在第一次嘗試降落。有四個離散動作可供選擇：什么都不做、發(fā)射左方位引擎、發(fā)射主引擎、發(fā)射右方位引擎。

8.5.1 主程序

這是我們的主程序, 在其中我們建立相關(guān)環(huán)境并調(diào)用了子函數(shù)來建立深度強化網(wǎng)絡(luò)模型進行訓練。神經(jīng)網(wǎng)絡(luò)框架采用pytorch, 神經(jīng)網(wǎng)絡(luò)部分簡單的采用3層全連接神經(jīng)網(wǎng)絡(luò)。

import gym
import random
import torch
import numpy as np
from collections import deque
import matplotlib.pyplot as plt
from dqn_agent import Agent
import osdef dqn(n_episode=2000, max_t=1000, eps_start=1.0, eps_end=0.01, eps_decay=0.995, mode='train'):"""Deep Q-Learning:param n_episode:maximum number of training episodes:param max_t:maximum number of timesteps per episode:param eps_start:starting value of epsilon, for epsilon-greedy action selection:param eps_end:minimum value of epsilon:param eps_decay:multiplicative factor (per episode) for decreasing epsilon:return: final score"""scores = []scores_window = deque(maxlen=100)eps = eps_startif mode == 'train':for i_episode in range(1, n_episode+1):# 初始化狀態(tài)state = env.reset()score = 0for t in range(max_t):action = agent.act(state, eps)next_state, reward, done, _ = env.step(action)agent.step(state, action, reward, next_state, done)state = next_statescore += rewardif done:breakscores_window.append(score)scores.append(score)eps = max(eps_end, eps_decay*eps)print('\rEpisode {}\t Average Score:{:.2f}'.format(i_episode, np.mean(scores_window)), end="")if i_episode % 100 == 0:print('\rEpisode {}\rAverage Score :{:.2f}'.format(i_episode, np.mean(scores_window)))if np.mean(scores_window) >= 200.0:print('\nEnvironment solved in {:d} episode! \t Average Score: {:.2f}'.format(i_episode, np.mean(scores_window)))torch.save(agent.qnetwork_local.state_dict(), 'checkpoint.pth')breakelse:# 訓練一次state = env.reset()for j in range(200):action = agent.act(state, eps)print('state :{} action :{}'. format(state, action))env.render()next_state, reward, done, _ = env.step(action)print('next_state={}, reward={}, done={}'.format(next_state, reward, done))agent.step(state, action, reward, next_state, done)if done:breakreturn scoresif __name__ == '__main__':os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'env = gym.make('LunarLander-v2')env.seed(0)print('State shape: ', env.observation_space.shape)print('Number of actions: ', env.action_space.n)MODE = 'train'if MODE == 'debug':# 調(diào)試模式agent = Agent(state_size=8, action_size=4, seed=1,debug_mode=True)scores = dqn(mode='test')elif MODE == 'run':agent = Agent(state_size=8, action_size=4, seed=1)agent.qnetwork_local.load_state_dict(torch.load('checkpoint.pth'))# 以當前策略運行for i in range(3):state = env.reset()for j in range(200):action = agent.act(state)env.render()state, reward, done, _ = env.step(action)if done:breakenv.close()else:# 訓練模式agent = Agent(state_size=8, action_size=4, seed=1)scores = dqn()# plot the scoresfig = plt.figure()ax = fig.add_subplot(111)plt.plot(np.arange(len(scores)), scores)plt.ylabel('Score')plt.xlabel('Episode #')plt.show()

程序注釋

	 MODE = 'train'if MODE == 'debug':# 調(diào)試模式agent = Agent(state_size=8, action_size=4, seed=1,debug_mode=True)scores = dqn(mode='test')elif MODE == 'run':agent = Agent(state_size=8, action_size=4, seed=1)agent.qnetwork_local.load_state_dict(torch.load('checkpoint.pth'))...else:# 訓練模式agent = Agent(state_size=8, action_size=4, seed=1)scores = dqn()

在這里提供了程序運行的三種模式,“debug”, “run”, "train"模式。debug模式是為了方便查看在程序運行過程中的各種參數(shù),方便程序調(diào)試和后期更改而設(shè)置的。run模式是在模型訓練完成后可以使用訓練完成的神經(jīng)網(wǎng)絡(luò)來查看最終效果。 train模式即訓練模式,沒有太多相關(guān)數(shù)據(jù)輸出。

8.5.2 DQN模型構(gòu)建程序

這部分為模型構(gòu)建子程序,包含了DQN最重要的算法。程序包含了3個類, 分別是class QNetwork, class Agent和class ReplayBuffer。

import numpy as np
import random
from collections import namedtuple, dequeimport torch
import torch.nn.functional as F
import torch.nn as nn
import torch.optim as optimBUFFER_SIZE = int(1e4)  # 經(jīng)驗回放的緩沖區(qū)的大小
BATCH_SIZE = 64  # 最小訓練批數(shù)量
GAMMA = 0.99  # 折扣率
TAU = 1e-3  # 用于目標函數(shù)的柔性策略更新
LR = 5e-4  # 學習率
UPDATE_EVERY = 4  # 更新網(wǎng)絡(luò)的頻率device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")class QNetwork(nn.Module):"""Actor (Policy) Model."""def __init__(self, state_size, action_size, seed, fc1_units=64, fc2_units=64):"""Initialize parameters and build model.Params======state_size (int): Dimension of each stateaction_size (int): Dimension of each actionseed (int): Random seed"""super(QNetwork, self).__init__()self.seed = torch.manual_seed(seed)self.fc1 = nn.Linear(state_size, fc1_units)self.fc2 = nn.Linear(fc1_units, fc2_units)self.fc3 = nn.Linear(fc2_units, action_size)def forward(self, state):"""Build a network that maps state -> action values."""x = F.relu(self.fc1(state))x = F.relu(self.fc2(x))return self.fc3(x)class Agent():"""與環(huán)境相互作用，從環(huán)境中學習。"""def __init__(self, state_size, action_size, seed, debug_mode=False):"""初始化智能體對象。Params======state_size (int): dimension of each stateaction_size (int): dimension of each actionseed (int): random seed"""self.state_size = state_sizeself.action_size = action_sizeself.seed = random.seed(seed)self.debug_mode = debug_modeprint('Program running in {}'.format(device))# Q-Networkself.qnetwork_local = QNetwork(state_size, action_size, seed).to(device)self.qnetwork_target = QNetwork(state_size, action_size, seed).to(device)self.optimizer = optim.Adam(self.qnetwork_local.parameters(), lr=LR)  # 自適應梯度算法# print('Q-Network_local:{}\nQ-Network_target:{}'.format(self.qnetwork_local, self.qnetwork_target))# 經(jīng)驗回放if self.debug_mode is True:self.memory = ReplayBuffer(action_size, BUFFER_SIZE, 1, seed)else:self.memory = ReplayBuffer(action_size, BUFFER_SIZE, BATCH_SIZE, seed)# 初始化時間步 (for updating every UPDATE_EVERY steps)self.t_step = 0def step(self, state, action, reward, next_state, done):# 在經(jīng)驗回放中保存經(jīng)驗self.memory.add(state, action, reward, next_state, done)# 在每個時間步UPDATE_EVERY中學習self.t_step = (self.t_step + 1) % UPDATE_EVERYif self.t_step == 0:# 如果內(nèi)存中有足夠的樣本，取隨機子集進行學習if len(self.memory) > BATCH_SIZE:experiences = self.memory.sample()self.learn(experiences, GAMMA)if self.debug_mode is True:experiences = self.memory.sample()self.learn(experiences, GAMMA)def act(self, state, eps=0.):"""根據(jù)當前策略返回給定狀態(tài)的操作.Params======state (array_like): 當前的狀態(tài)eps (float): epsilon, 用于 epsilon-greedy action selection"""state = torch.from_numpy(state).float().unsqueeze(0).to(device)# 將qn更改成評估形式self.qnetwork_local.eval()# 禁用梯度with torch.no_grad():# 獲得動作價值action_values = self.qnetwork_local(state)# 將qn更改成訓練模式self.qnetwork_local.train()# Epsilon-greedy action selectionif random.random() > eps:return np.argmax(action_values.cpu().data.numpy())else:return random.choice(np.arange(self.action_size))def learn(self, experiences, gamma):"""使用給定的一批經(jīng)驗元組更新值參數(shù)。Params======experiences (Tuple[torch.Tensor]): tuple of (s, a, r, s', done) tuples gamma (float): discount factor"""states, actions, rewards, next_states, dones = experiencesif self.debug_mode is True:print('\nstates={}, actions={}, rewards={}, next_states={}, dones={}'.format(states, actions, rewards, next_states, dones))# compute and minimize the loss# 從目標網(wǎng)絡(luò)得到最大的預測Q值(下一個狀態(tài))Q_targets_next = self.qnetwork_target(next_states).detach().max(1)[0].unsqueeze(1)# 計算當前狀態(tài)的Q目標Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))# 從評估網(wǎng)絡(luò)中獲得期望的Q值Q_expected = self.qnetwork_local(states).gather(1, actions)if self.debug_mode is True:print('Q_target_next={}, \nQ_target ={}, \nQ_expected={},'.format(Q_targets_next, Q_targets, Q_expected))# Compute lossloss = F.mse_loss(Q_expected, Q_targets)# Minimize the lossself.optimizer.zero_grad()loss.backward()# 執(zhí)行單個優(yōu)化步驟self.optimizer.step()# ------------------- update target network ------------------- #self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU)def soft_update(self, local_model, target_model, tau):""":柔性更新模型參數(shù)。θ_target = τ*θ_local + (1 - τ)*θ_targetParams======local_model (PyTorch model): weights will be copied fromtarget_model (PyTorch model): weights will be copied totau (float): 插值參數(shù)"""for target_param, local_param in zip(target_model.parameters(), local_model.parameters()):# 柔性更新, 將src中數(shù)據(jù)復制到self中target_param.data.copy_(tau * local_param.data + (1.0 - tau) * target_param.data)class ReplayBuffer:"""Fixed-size buffer to store experience tuples."""def __init__(self, action_size, buffer_size, batch_size, seed):"""Initialize a ReplayBuffer object.Params======action_size (int): dimension of each actionbuffer_size (int): maximum size of bufferbatch_size (int): size of each training batchseed (int): random seed"""self.action_size = action_sizeself.memory = deque(maxlen=buffer_size)self.batch_size = batch_sizeself.experience = namedtuple("Experience", field_names=["state", "action", "reward", "next_state", "done"])self.seed = random.seed(seed)def add(self, state, action, reward, next_state, done):"""在memory中添加一段新的經(jīng)驗."""e = self.experience(state, action, reward, next_state, done)self.memory.append(e)def sample(self):"""從memory中隨機抽取一批經(jīng)驗."""experiences = random.sample(self.memory, k=self.batch_size)states = torch.from_numpy(np.vstack([e.state for e in experiences if e is not None])).float().to(device)actions = torch.from_numpy(np.vstack([e.action for e in experiences if e is not None])).long().to(device)rewards = torch.from_numpy(np.vstack([e.reward for e in experiences if e is not None])).float().to(device)next_states = torch.from_numpy(np.vstack([e.next_state for e in experiences if e is not None])).float().to(device)dones = torch.from_numpy(np.vstack([e.done for e in experiences if e is not None]).astype(np.uint8)).float().to(device)return (states, actions, rewards, next_states, dones)def __len__(self):"""Return the current size of internal memory."""return len(self.memory)

程序注釋

class QNetwork類構(gòu)建了三層的神經(jīng)網(wǎng)絡(luò)模型,class ReplayBuffer類定義了關(guān)于經(jīng)驗回訪的相關(guān)功能。class Agent是最重要的類,它調(diào)用了class QNetwork和class ReplayBuffer來創(chuàng)建DQN模型。所以我們主要看一下class Agent的相關(guān)函數(shù)和功能。

---

        self.state_size = state_sizeself.action_size = action_sizeself.seed = random.seed(seed)self.debug_mode = debug_mode# Q-Networkself.qnetwork_local = QNetwork(state_size, action_size, seed).to(device)self.qnetwork_target = QNetwork(state_size, action_size, seed).to(device)self.optimizer = optim.Adam(self.qnetwork_local.parameters(), lr=LR)  # 自適應梯度算法

初始化智能體對象,并構(gòu)建神經(jīng)網(wǎng)絡(luò)。在這里我們需要建立兩個神經(jīng)網(wǎng)絡(luò)，其中“qnetwork_local”作為訓練使用的神經(jīng)網(wǎng)絡(luò)，在此之外，我們還要建立qnetwork_target目標網(wǎng)絡(luò)，來優(yōu)化我們的訓練過程。在這里使用了“自適應梯度算法”來作為神經(jīng)網(wǎng)絡(luò)的優(yōu)化器。

---

        # 經(jīng)驗回放if self.debug_mode is True:self.memory = ReplayBuffer(action_size, BUFFER_SIZE, 1, seed)else:self.memory = ReplayBuffer(action_size, BUFFER_SIZE, BATCH_SIZE, seed)

根據(jù)相關(guān)的模式來建立經(jīng)驗回放功能的類。

---

	def step(self, state, action, reward, next_state, done):...def act(self, state, eps=0.):...def learn(self, experiences, gamma):...def soft_update(self, local_model, target_model, tau):

這些是在訓練過程中使用到的函數(shù)，它們的功能如下所示。其作用是方便與理解，其關(guān)系并不是完全如圖所示的流線型關(guān)系。例如，soft_update函數(shù)是在learn函數(shù)中調(diào)用的的一個函數(shù)，其關(guān)系并不算是線性的。

8.5.3 程序測試

接下來將模式設(shè)置為Mode = train運行程序進行訓練，要實現(xiàn)平均分數(shù)大于200分的目標，我的電腦需要跑40分鐘左右。使用run模式運行模型如下，

8.6 雙重深度Q網(wǎng)絡(luò)

之前曾提到Q學習會帶來最大化偏差，而雙重Q學習卻可以消除最大化偏差?；诓檎冶淼碾p重Q學習引入了兩個動作價值的估計$Q(0)$和$Q(1)$，每次更新動作價值時用其中的一個網(wǎng)絡(luò)確定動作，用確定的動作和另外一個網(wǎng)絡(luò)來估計回報。對于深度Q學習也有同樣的結(jié)論。Deepmind于2015年發(fā)表論文《Deepreinforcement learning with double Q-learning》，將雙重Q學習用于深度Q網(wǎng)絡(luò)，得到了雙重深度Q網(wǎng)絡(luò)（Double Deep Q Network，Double DQN）。考慮到深度Q網(wǎng)絡(luò)已經(jīng)有了評估網(wǎng)絡(luò)和目標網(wǎng)絡(luò)兩個網(wǎng)絡(luò)，所以雙重深度Q學習在估計回報時只需要用評估網(wǎng)絡(luò)確定動作，用目標網(wǎng)絡(luò)確定回報的估計即可。所以，只需要將
$$y=r+\gamma \underset{a}{\max }Q(s^{\prime },a;{\theta }_{target})$$
更改為
$$y=r+\gamma Q(s^{\prime },\underset{a}{\mathrm{argmax}}Q(s^{\prime },a;{\theta }_i);{\theta }^{?})$$
就得到了帶經(jīng)驗回放的雙重深度Q網(wǎng)絡(luò)算法。

8.7 對偶深度Q網(wǎng)絡(luò)

Z.Wang等在2015年發(fā)表論文《Dueling network architectures for deepreinforcement learning》，提出了一種神經(jīng)網(wǎng)絡(luò)的結(jié)構(gòu)——對偶網(wǎng)絡(luò)（duelnetwork）。對偶網(wǎng)絡(luò)理論利用動作價值函數(shù)和狀態(tài)價值函數(shù)之差定義了一個新的函數(shù)——優(yōu)勢函數(shù)（advantage function）:
$$A(s,a)=Q(s,a)?V(s,a)$$
對偶Q網(wǎng)絡(luò)仍然用$Q(\theta )$來估計動作價值，只不過這時候$Q(\theta )$是狀態(tài)價值估計$V(s;\theta )$和優(yōu)勢函數(shù)估計$A(s,a;\theta )$的疊加，即
$$Q(s,a;\theta )=V(s;\theta )+A(s,a;\theta )$$

其中$V(\theta )$和$A(\theta )$可能都只用到了$\theta$中的部分參數(shù)。在訓練的過程中，$V(\theta )$和$A(\theta )$是共同訓練的，訓練過程和單獨訓練普通深度$Q$網(wǎng)絡(luò)并無不同之處。

---

1. 來自于《強化學習：原理與python實現(xiàn)》 ??

2. 參考于《Human-level control through deep reinforcement learning》Volodymyr Mnih等 ??

總結(jié)

以上是生活随笔為你收集整理的强化学习（八） - 深度Q学习(Deep Q-learning, DQL,DQN)原理及相关实例的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。