強化學習（五）—— AlphaGo與Alpha Zero

• 1. AlphaGo
• • 1.1 論文鏈接
  • 1.2 輸入編碼（State）
  • 1.3 訓練及評估流程
  • 1.4 模仿學習（Behavior Cloning）
  • 1.5 策略網絡依據策略梯度進行學習
  • 1.6 價值網絡訓練
  • 1.7 Monte Carlo Tree Search
  • • 1.7.1 Selection
    • 1.7.2 Expansion
    • 1.7.3 Evaluation
    • 1.7.4 Backup
  • 1.8 使用MCTS進行決策
• 2. AlphaGo Zero
• • 2.1 論文鏈接
  • 2.2 基于AlphaGo的改進內容
  • 2.2 策略網絡的訓練
• 3. 代碼實現
• • 3.1 策略網絡和狀態價值網絡實現
  • • 3.1.1 代碼
    • 3.1.2 結果
  • 3.2 蒙特卡洛樹搜索算法

1. AlphaGo

1.1 論文鏈接

查看原文

1.2 輸入編碼（State）

• 棋盤大小：[19,19]的矩陣, 落子則為1，反之為0。
• Input Shape:[19,19,17]。
• 白棋當前狀態及其過去7步的狀態：[19,19,1]與[19,19,7]。
• 黑棋當前狀態及其過去7步的狀態：[19,19,1]與[19,19,7]。
• 當前到誰落子：[19,19,1] (黑棋全為1，白棋全為0)

1.3 訓練及評估流程

使用behavior cloning 對策略網絡進行初步訓練；

兩個策略網絡互相對弈，并使用策略梯度對策略網絡進行更新；

使用策略網絡去訓練狀態價值網絡；

基于策略網絡和價值網絡，使用蒙特卡洛樹（Monte Carlo Tree Search， MCTS）進行搜索。

1.4 模仿學習（Behavior Cloning）

通過Behavior Cloning從人的經驗中初始化策略網絡的參數，策略網絡的結構為：
隨機初始化網絡參數后，基于人類對弈的落子序列數據，進行模仿學習（分類任務），使用交叉熵作為損失函數進行參數更新：

觀測得到狀態：$$s_t$$

使用策略網絡進行預測$$p_t=[\pi (1|s_t;\theta ),\pi (2|s_t;\theta ),...,\pi (361|s_t;\theta )]$$

高級人類玩家采取的動作為$$a_t^{?}$$

策略網絡的預測進行one-hot編碼后，和人類玩家的動作進行交叉熵計算，并更新網絡參數。
模仿學習可認為是循規蹈矩。

1.5 策略網絡依據策略梯度進行學習

兩個策略網絡進行對弈直到游戲結束。Player V.S. Opponent，Player 使用策略網絡最新的參數，Opponent隨機選用過去迭代中的網絡參數。

得到對弈的序列數據：$$s_1,a_1,s_2,a_2,s_3,a_3,...,s_T,a_T$$

Player獲得的回報為：$$u_1=u_2=u_3=u_T(贏了為1，輸了為?1)$$

近似策略梯度(連加)$$g_{\theta }=\sum _{t=1}^T\frac{?log(\pi (?|s_t;\theta ))}{?\theta }?u_t$$

參數更新$$\theta \leftarrow \theta +\beta ?g_{\theta }$$

1.6 價值網絡訓練

• 狀態價值函數：$$\begin{gathered} V_{\pi }(S)=E(U_t|S_t=s) \\ {U}_t=1(win) \\ {U}_t=?1(fail) \end{gathered}$$
• 神經網絡近似狀態價值函數：$$v(s;W)～V_{\pi }(s)$$
• 訓練過程：

兩個策略網絡進行對弈直到游戲結束$$u_1=u_2=u_3=u_T(贏了為1，輸了為?1)$$

損失函數：$$L=\sum _{t=1}^T\frac{1}{2}[v(s_t;W)?u_t{]}^2$$

進行參數更新：$$W\leftarrow W?\alpha ?\frac{?L}{?W}$$

1.7 Monte Carlo Tree Search

每次蒙特卡洛樹（MCTS）的搜索過程：

Selection：假想Player依據當前狀態執行一次動作$$\begin{gathered} s_t \\ {a}_t \end{gathered}$$

Expansion: 假想對手做一次動作，并更新狀態：$$s_{t+1}$$

Evaluation: 使用狀態價值網絡評估得到價值分數：$$\nu =v(s_{t+1};W)$$假想對弈直到結束，得到獎勵：$$r$$給假想動作進行打分：$$score(a_t)=\frac{\nu +r}{2}$$

Backup:對動作的分數進行更新。

1.7.1 Selection

觀測到狀態$$s_t$$

對于所有可選動作，計算其選擇分數：$$\mathrm{s}\mathrm{c}\mathrm{o}\mathrm{r}\mathrm{e}(a)=Q(a)+\eta ?\frac{\pi (a|s_t;\theta )}{1+N(a)}$$Q(a)為通過MRTS得到的動作價值，N(a)為在t時刻狀態下已搜索過動作a的次數。

具有最高選擇分數的動作被選中。

1.7.2 Expansion

由于狀態轉移函數未知，則用策略函數作為狀態轉移函數

依據策略函數和對手觀測到的狀態，隨機采樣得到對手的動作：$$a_t^{‘}～\pi (?|s_t^{{}^{\prime }};\theta )$$

對手的動作將導致新的狀態生成：$$s_{t+1}$$

1.7.3 Evaluation

重復對弈直至游戲結束，Player的動作：$$a_k～\pi (?|s_k;\theta )$$Opponents的動作：$$a_k^{{}^{\prime }}～\pi (?|s_k^{{}^{\prime }};\theta )$$

記錄對局結束后的回報：$$\begin{gathered} win:r_T=+1 \\ lose:r_T=?1 \end{gathered}$$

計算 t+1時刻的狀態價值：$$\nu (s_{t+1};W)$$

t+1時刻狀態的價值分數：$$V(s_{t+1})=\frac{1}{2}\nu (s_{t+1};W)+\frac{1}{2}{r}_T$$

1.7.4 Backup

對選取t時刻動作后的過程重復多次：$$a_t$$

t時刻動作的每個子節點對應多條價值分數記錄，取平均值更新Q值（在Selection中用到）：$$Q(a_t)=mean(therecorded{V}_s^{{}^{\prime }})$$

1.8 使用MCTS進行決策

• 動作a被選中的次數為：$$N(a)$$
• 在進行MCTS后，被選中次數最多的動作被Player用于最后決策：$$a_t=\underset{a}{\mathrm{argmax}}N(a)$$
• 執行完該次決策后，Q值和N值被重置為0：$$\begin{gathered} Q(a)=0 \\ N(a)=0 \end{gathered}$$

2. AlphaGo Zero

2.1 論文鏈接

查看原文

2.2 基于AlphaGo的改進內容

• AlphaGo Zero未使用Behavior cloning（未使用人類經驗）
• 策略網絡的訓練過程中使用MCTS。

2.2 策略網絡的訓練

AlphaGo Zero使用MCTS訓練策略網絡

觀測到狀態：$$s_t$$

通過策略網絡進行預測：$$p=[\pi (a=1|s_t,\theta ),...,\pi (a=361|s_t,\theta )]\in R^{361}$$

通過MCTS進行預測：$$n=normalize[N(a=1),N(a=2),...,N(a=361)]\in R^{361}$$

計算損失：$$L=CrossEntropy(n,p)$$

對網絡參數進行更新：$$\theta \leftarrow \frac{?L}{?\theta }$$

3. 代碼實現

3.1 策略網絡和狀態價值網絡實現

3.1.1 代碼

# -*- coding: utf-8 -*- # @Time : 2022/4/1 13:47 # @Author : CyrusMay WJ # @FileName: resnet.py # @Software: PyCharm # @Blog ：https://blog.csdn.net/Cyrus_Mayimport tensorflow as tf import logging import sys import os os.environ["PATH"] += os.pathsep + 'D:\software_root\Anoconda3\envs\AI\Graphviz\\bin' # 用于網絡結構畫圖 class ResidualNet():def __init__(self,input_dim,output_dim,net_struct,l2_reg=0,logger=None):""":param input_dim::param output_dim::param net_struct: a list for residual network, net_struct[0] is the first CNN for inputs,the rest is single block for residual connect. e.g. net_struct = [{filters:64,kernel_size:(3,3), {filters:128,kernel_size:(3,3),{filters:128,kernel_size:(3,3)}]:param logger:"""self.logger=loggerself.input_dim = input_dimself.output_dim=output_dimself.l2_reg = l2_regself.__build_model(net_struct)def conv_layer(self,x,filters,kernel_size):x = tf.keras.layers.Conv2D(filters=filters,kernel_size=kernel_size,activation="linear",padding="same",data_format="channels_last",kernel_regularizer=tf.keras.regularizers.l2(self.l2_reg),bias_regularizer=tf.keras.regularizers.l2(self.l2_reg))(x)x = tf.keras.layers.BatchNormalization(axis=-1)(x)x = tf.keras.layers.LeakyReLU()(x)return xdef residual_block(self,inputs,filters,kernel_size):x = self.conv_layer(inputs,filters,kernel_size)x = tf.keras.layers.Conv2D(filters=filters,kernel_size=kernel_size,activation="linear",padding="same",data_format="channels_last",kernel_regularizer=tf.keras.regularizers.l2(self.l2_reg),bias_regularizer=tf.keras.regularizers.l2(self.l2_reg))(x)x = tf.keras.layers.BatchNormalization(axis=-1)(x)if inputs.shape[-1] == filters:x = tf.keras.layers.add([inputs,x])else:inputs = tf.keras.layers.Conv2D(filters=filters,kernel_size=(1,1),activation="linear",padding="same",data_format="channels_last",kernel_regularizer=tf.keras.regularizers.l2(self.l2_reg),bias_regularizer=tf.keras.regularizers.l2(self.l2_reg))(inputs)x = tf.keras.layers.add([inputs, x])x = tf.keras.layers.LeakyReLU()(x)return xdef policy_head(self,inputs):x = tf.keras.layers.Conv2D(filters=2,kernel_size=(1,1),activation="linear",padding="same",data_format="channels_last",kernel_regularizer=tf.keras.regularizers.l2(self.l2_reg),bias_regularizer=tf.keras.regularizers.l2(self.l2_reg))(inputs)x = tf.keras.layers.Flatten()(x)x = tf.keras.layers.Dense(units=self.output_dim,activation="linear",kernel_regularizer=tf.keras.regularizers.l2(self.l2_reg),bias_regularizer=tf.keras.regularizers.l2(self.l2_reg),name="policy_head")(x)return xdef state_value_head(self,inputs):x = tf.keras.layers.Conv2D(filters=2,kernel_size=(1, 1),activation="linear",padding="same",data_format="channels_last",kernel_regularizer=tf.keras.regularizers.l2(self.l2_reg),bias_regularizer=tf.keras.regularizers.l2(self.l2_reg))(inputs)x = tf.keras.layers.Flatten()(x)x = tf.keras.layers.Dense(units=1,activation="linear",kernel_regularizer=tf.keras.regularizers.l2(self.l2_reg),bias_regularizer=tf.keras.regularizers.l2(self.l2_reg),name="state_value_head")(x)return xdef __build_model(self,net_struct):input_layer = tf.keras.layers.Input(shape=self.input_dim,name="inputs")x = self.conv_layer(input_layer,net_struct[0]["filters"],net_struct[0]["kernel_size"])for i in range(1,len(net_struct)):x = self.residual_block(x,net_struct[i]["filters"],net_struct[i]["kernel_size"])v_output = self.state_value_head(x)p_output = self.policy_head(x)self.model = tf.keras.models.Model(inputs=input_layer,outputs=[p_output,v_output])tf.keras.utils.plot_model(self.model, to_file="./AlphZero.png")self.model.compile(optimizer=tf.optimizers.Adam(),loss = {"policy_head":tf.nn.softmax_cross_entropy_with_logits,"state_value_head":"mean_squared_error"},loss_weights={"policy_head":0.5,"state_value_head":0.5})if __name__ == '__main__':logger = logging.getLogger(name="ResidualNet")logger.setLevel(logging.INFO)screen_handler = logging.StreamHandler(sys.stdout)screen_handler.setLevel(logging.INFO)formatter = logging.Formatter('%(asctime)s - %(module)s.%(funcName)s:%(lineno)d - %(levelname)s - %(message)s')screen_handler.setFormatter(formatter)logger.addHandler(screen_handler)residual_net = ResidualNet(logger=logger,input_dim=[19,19,17],output_dim=19*19,net_struct=[{"filters":64,"kernel_size":(3,3)},{"filters": 128, "kernel_size": (3, 3)},{"filters": 128, "kernel_size": (3, 3)},{"filters": 64, "kernel_size": (3, 3)},{"filters": 64, "kernel_size": (3, 3)},])

3.1.2 結果

3.2 蒙特卡洛樹搜索算法

參考我的另一篇博客。

本文部分內容為參考B站學習視頻書寫的筆記！

by CyrusMay 2022 04 04

當時有多少的心愿
就有多少的殘缺
————五月天（步步）————

總結

以上是生活随笔為你收集整理的强化学习（五）—— AlphaGo与Alpha Zero的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。