翻譯Deep Learning and the Game of Go（11）第九章：靠實踐學習：強化學習

本章包括：

1. 爲強化學習定義一個任務
2. 爲遊戲構建一個學習代理
3. 爲訓練收集自我遊戲經驗

我可能已經讀過十幾本關於圍棋的書，這些書都是由來自中國、韓國和日本的強大專業人士寫的，但我依舊只是一箇中等的業餘棋手。爲什麼我沒有達到和這些傳奇一樣的水平呢？是因爲我忘記他們的課程嗎？不是這樣的；我實際上可以背誦Toshiro Kageyama對於圍棋基礎的一些經驗，也許我只需要讀更多的書.。

我不知道成爲頂級圍棋高手的全部祕方，但我至少知道我和圍棋專業人士的一個區別：練習。圍棋棋手在獲得專業資格之前，至少需要練五千到一萬盤。實踐創造知識，有時這是你無法直接交流的知識。你可以總結這種知識——這就是圍棋書籍存在的意義。如果我希望掌握我讀過的課程，我需要投入類似的練習時間。

如果練習對人類如此寶貴，那麼對於計算機呢？計算機程序能通過練習來學習嗎？這就是強化學習的真諦。在強化學習（R L）中，您通過反覆嘗試一個任務來改進一個程序。當它有良好的結果，您可以修改程序以重複這種決定。當它有壞的結果時，您可以修改程序以避免這些決定。這並不意味着在每次試驗之後都要編寫新代碼：RL算法提供了進行這些修改的自動化方法。

強化學習使用起來並不輕鬆。首先，它很慢：你的機器人需要玩成千上萬的遊戲纔能有所長進。此外，訓練過程非常繁瑣，難以調試。但是，如果你努力將這些技術融入到你的AI中，回報是巨大的。你可以構建一個使用複雜策略的軟件去處理一系列任務，即使你自己不知道其策略

本章就介紹強化學習的週期。接下來，你將看到如何建立一個圍棋機器人，讓它以一種適合強化學習的方式與自己對抗。第10章就展示瞭如何使用自我對弈的數據去提高機器人的性能。 

9.1 強化學習週期 

許多算法實現了強化學習的力學，但它們都在標準框架內工作。本節描述強化學習週期，其中計算機程序通過反覆嘗試一項任務來改進。圖9.1說明了週期。 

圖9.1.  強化學習週期:可以通過多種方式實現強化學習，但整體過程有共同的結構。首先，計算機程序嘗試重複一個任務。這些嘗試的記錄被稱爲經驗數據。接下來，您修改行爲以模仿更成功的嘗試；這個過程是訓練。然後你會定期評估確認程序正在改進。通常，您需要重複這個過程多次。 

在強化學習中，您的圍棋AI是一個爲了完成任務而做出決策的程序。在本書的前面部分，您實現了選擇圍棋落子的各種版本的Agent。在這些情況下，你給AI提供了一個GameState對象，使它可以用一個決定(即一個落子)來回應。儘管你那時沒有使用強化學習，但AI的原理是一樣的。

強化學習的目標是使AI儘可能有效。在這種情況下，你想讓你的AI去贏。

首先，你讓你的圍棋AI跟自己玩了一批遊戲；在每一場比賽中，它應該記錄每一個回合和最後的結果。這些遊戲記錄被稱爲它的經驗。

接下來，你通過在其自我對弈過程中發生的事情去更新AI的行爲來訓練你的AI。這一過程類似於第6章和第7章所涵蓋的神經網絡的訓練。這個核心思想是，你希望AI能夠重複它在贏棋中做出的決定，並停止在它輸棋中做出的決定。訓練算法作爲一個軟件包來處理你AI的結構：爲了訓練你需要能夠系統地修改你的AI行爲。有許多算法都可以做到這一點；我們在這本書中涵蓋了三個算法。在這一章和接下來的一章，我們將學習策略梯度算法。在第11章中，我們將討論Q-learning算法。第12章將介紹actor-critic算法。

訓練後，你希望你的機器人能夠更強大。但是訓練過程有很多地方會出錯，因此評估機器人的進展以確認其實力是個好主意。要評估一個玩遊戲的AI，需要讓它玩更多的遊戲。您可以將你的AI與早期版本進行對弈，以衡量其水平。要做一個全面的測試，你也可以定期將你的AI與其他AI或你進行對弈

然後你可以無限期地重複整個週期：

• 收集經驗
• 訓練
• 評估

我們將把這個週期分成多個腳本。在本章中，您將實現一個自我對弈腳本，該腳本將模擬自我對弈，並將經驗數據保存到磁盤。在下一章中，您將製作一個訓練腳本，將經驗數據爲輸入，相應地更新AI，並保存新的AI

9.2.什麼將成爲經驗？ 

在第三章中，您設計了一組用於表示圍棋遊戲的數據結構。您可以想象如何通過使用諸如Move、GoBoard和GameState等類來存儲整個遊戲記錄。而強制學習算法是通用的：它們處理一個問題的高度抽象表示，因此相同的算法可以應用於儘可能多的問題領域。本節就展示如何使用強化學習的語言來描述遊戲記錄。

在玩遊戲的情況下，你可以把你的經驗分爲個人遊戲和一段變化。每一個變化都有一個明確的結局，一個變化做出的決定不會影響另一個變化的決定。在其他領域，你可能沒有任何明顯的方法來把經驗分成各種變化；例如，一個機器人，被設計用來連續操作，去做無止盡的決策。你仍然可以將強化學習應用於這類問題，但這裏的變化邊界使它變得更簡單。

在一個變化中，一個AI面臨着它的環境狀態。基於當前狀態，AI必須選擇一個動作。在選擇一個動作後，AI將看到一個新的狀態；下一個狀態取決於無論是選擇的行動和環境中發生的其他事情。在圍棋中，您的AI將看到一個棋盤盤面（狀態），然後選擇一個合法的落子。在那之後，AI將在下一個回合中看到一個新的棋盤局面。

注意，在AI選擇一個落子後，下一個狀態也包括對手的落子。你無法根據當前的遊戲狀態去確定下一個狀態以及您要選擇的落子：您還必須等待對手的落子。對手的行爲也是環境的一部分，你的AI必須學會適應。

爲了提升水平，你的AI需要反饋它是否達到了目標。你可以通過計算它的回報來提供反饋，這是一個達到目標的分數。對於你的圍棋AI來說，目標是贏得對局，你可以在它贏一局棋時加1，以及在其輸一局時減1。強化學習算法將改變AI的行爲，從而增加它的回報量。圖9.2說明了如何用狀態、動作和獎勵來描述圍棋遊戲。

圖9.2，一個5*5的遊戲，圍棋翻譯成強化學習的語言..你想訓練的是黑棋。它看到一系列狀態（棋盤局面）並選擇落子（合法落子）。在一個變化（一個完整的遊戲）結束時，它將得到一個獎勵，以表明它是否達到了它的目標。在這種情況下，黑色贏得了遊戲，所以給它獎勵了1。

圍棋和類似的遊戲都是特殊情況：在遊戲結束時計算一次回報，而回報只有兩種可能：你贏了或輸了，你不在乎遊戲中還會發生什麼情況。在其他領域，回報可能會分散開來。想象一下讓AI玩拼字遊戲。在每一個回合中，AI都會放置一個單詞和積分，然後它的對手也會做同樣地事情。在這種情況下，您可以計算人工智能積分的正回報，以及對手積分的負回報。然後人工智能就不需要一直等到一個變化結束後才能得到回報；在它採取的每一個落子之後，它都會得到很少的回報。

強化學習的一個關鍵思想是，一個行動可能要爲一個回報負責，而這個回報要晚得多。想象一下你在一個對局中第35步下了一個聰明的落子，並繼續下200步後獲勝。那該棋局的早期階段落子至少得爲這場勝利贏得一些讚譽。你必須以某種方式來獎勵遊戲中的所有落子。你的AI在一個落子之後看到的未來回報就稱爲該落子的回報。爲了計算一個動作的回報，你需要在把這一行動之後直到對局結束的所有回報加起來，如下面代碼所示。這是一種方式，你實現並不知道，哪些落子是可以贏或輸。他通過學習算法，以區分信任或指責個別落子。 

for exp_idx in range(exp_length): 
    #reward[i]是在落子i後立馬看到的回報
    total_return[exp_idx] = reward[exp_idx] 
    for future_reward_idx in range(exp_idx + 1, exp_length): 
        #在所有未來的回報上循環遍歷，並將它們添加到當前回報中
        total_return[exp_idx] += reward[future_reward_idx] 

這一假設並不能解釋每一個問題。再想想我們的拼字遊戲例子，你第一輪的決定可能會影響你第三輪的得分，但很難看出你第三輪的決定會如何影響你的第二十輪。爲了表示這種概念，您可以計算每個動作的未來回報加權和。當你離動作更遠的時候，權重應該會變小，這樣未來的回報就會比立即的回報影響更少。

這種技術叫做折扣獎勵。下面代碼就展示瞭如何計算折扣收益。在這個例子中，每一個動作都會立即得到全部的回報。但下一步的回報只能有75%那麼多；兩步的回報計算出來只能有75%×75%=56%那麼多，以此類推。選擇75%只是一個例子；正確的折扣率將取決於你的特定域，你可能需要進行一點實驗才能找到最有效的數字。

for exp_idx in range(exp_length):
    discounted_return[exp_idx] = reward[exp_idx] 
    discount_amount = 0.75
    # 折扣率會越來越小，當你從原來的動作中得到進一步的時候.
    for future_reward_idx in range(exp_idx + 1, exp_length): 
       discounted_return[exp_idx] += discount_amount * reward[future_reward_idx] 
       discount_amount *= 0.75

在建立圍棋AI的情況下，唯一可能的回報是輸贏。這可以讓您在返回計算中走了捷徑。當你的AI獲勝時，遊戲中的每一個落子都有1的回報。當你的AI輸了，每個落子都有-1的回報。

9.3.建造一個可以學習的AI 

強化學習不能憑空創建一個圍棋AI，或任何其他類型的AI。它只能提升一個已經在遊戲參數範圍內工作的AI。開始階段，你需要一個至少可以完成一個完整遊戲的AI。本節就演示瞭如何創建一個圍棋AI通過使用神經網絡來選擇落子。如果你從一個未經訓練的網絡開始，AI就會玩得跟你第三章的隨機落子AI一樣糟糕。以後可以通過強化學習來完善這個神經網絡

一個策略是對於一個給定狀態去選擇操作的函數。前幾章您看到了Agent類的幾個實現，它們具有select_move函數。每個select_move函數都是一個策略：一個遊戲狀態輸入進來，然後輸出一個落子。從他們產生合法的落子來說，至今你實現的所有策略都是有效的。但它們並不是同樣好：第4章中的MCTSAgent將經常地擊敗第3章中的RandomAgent。.如果您想提高這些AI中的一個，您需要考慮改進算法，編寫新的代碼，並測試它-----標準軟件開發過程。

爲了使用強化學習，您需要一個可以使用另一個計算機程序自動更新的策略。在第6章中，你研究了一類函數，讓你精確地做到這一點：卷積神經網絡。一個深度神經網絡可以計算複雜的邏輯，並且可以使用梯度下降算法修改其行爲。

你在第六章和第七章中設計的落子預測神經網絡輸出了帶有棋盤上每個點預測值的向量；該值表示該點將是下一個落子的概率。如何根據這樣的輸出形成策略？一種方法是簡單的選擇具有最高值的落子。如果您的網絡已經被訓練來選擇好的落子，這將產生良好的結果。但對於任何給定的棋盤局面，它都會選擇相同的落子，這就產生了強化學習的問題。要通過強化學習來提高，需要選擇多種落子，有的會更好，有的會更壞；你可以觀察他們產生的結果來檢測落子。但你爲了提高必須要多種變化。

不要每次選擇最高概率的落子，你想要一個隨機策略。這裏，隨機意味着如果您輸入了兩次完全相同的棋盤局面，您的AI可以選擇不同的落子。這涉及到了隨機性，但不與第三章中的隨機落子AI採用相同的方式。RandomAgent選擇落子時根本不考慮遊戲中發生的事情，而隨機策略意味着您的落子選擇將取決於棋盤狀態，但它不會100%可預測。 

 9.3.1.從概率分佈中採樣

對於任何棋盤局面，你的神經網絡都會給您提供一個向量，使得每個元素對應一個棋盤局面。若要從中創建策略，可以對於向量中的每個元素都視爲指示你選擇一個特定落子的可能性。本節演示如何根據這些概率來選擇落子。

例如，如果你在玩石頭剪刀布，你可以遵循選擇50%的時間出石頭，30%的時間出布，20%的時間出剪刀。50%~30%~20%的分割是三種選擇的概率分佈。注意概率和正好是100%：這是因爲您的策略必須始終從這三個中選擇一個。這是概率分佈的一個必要屬性；50%~30%~10%的政策將會讓你在10%的時間做不出決定。

從這些概率分佈中隨機選擇其中一個的過程稱爲抽樣。下面的代碼就顯示了這樣一個Python函數，它將根據該策略選擇其中一個選項。

import random def rps():
  randval = random.random() 
  if 0.0 <= randval < 0.5: 
      return 'rock'
  elif 0.5 <= randval < 0.8:
      return 'paper' 
  else:
      return 'scissors'

嘗試運行上面的代碼，你會看到比布更多的石頭，比剪刀更多的布，但三者都會定期出現。

從概率上取樣的邏輯分佈被構建到NumPy中，作爲np.random.choice函數。下面的列表顯示了使用NumPy實現的完全相同的行爲

import numpy as np


def rps():
    return np.random.choice( ['rock', 'paper', 'scissors'], p=[0.5, 0.3, 0.2])

 此外，np.random.choice將處理來自同一分佈的重複採樣。它將從您的分佈中採樣一次，並從列表中刪除該項目，並從其餘的項目中再次採樣。在這種情況下，你就得到了一個半隨機有序列表。高概率項目很可能出現在榜單的前幾位，但仍有一些變化。下面的列表展示瞭如何使用np.random.choice進行重複採樣。您指示size=3表示您想要三個不同的項，並寫replace=false表示您不希望重複任何結果。

import numpy as np


def rps():
    return np.random.choice( ['rock', 'paper', 'scissors'], size=3, replace=False, p=[0.5, 0.3, 0.2])

 如果您的圍棋策略推薦了一個無效移動，則重複採樣將是有用的。在這種情況下，你會想選擇另一個。你可以調用np.random.choice一次，然後沿着它生成的列表去工作。

9.3.2.剪輯概率分佈 

強化學習過程可能相當不穩定，特別是在早期。AI可能對幾次獲勝的機會反應過度，並暫時將很高的概率分配給那些不是真正很 好的落子。（在這方面，這和人類初學者沒有什麼不同！）一個特定的移動概率一直到1是可能的。這就造成了一個微妙的問題：因爲你的AI總是選擇相同的落子，它沒有機會去忘記它。

爲了防止這種情況，您將剪輯概率分佈，以確保沒有概率被推到0或1。你在第八章的深度學習AI做了相同的事情。來自NumPy的np.clip函數處理這裏的大部分工作。

import numpy as np


def clip_probs(original_probs):
    min_p = 1e-5
    max_p = 1-min_p
    clipped_probs = np.clip(original_probs, min_p, max_p)
    # 確保結果仍然是有效的概率分佈
    clipped_probs = clipped_probs / np.sum(clipped_probs)
    return clipped_probs

9.3.3.初始化AI

讓我們開始構建一種新的AI，一種策略AI，它將根據隨機策略選擇移動，並且可以從經驗數據中學習。這個模型可以與來自第6章和第7章的落子預測AI同一；唯一的區別是你訓練它的方式。您可以將dlgo/agent/pg.py模塊添加到dlgo庫中。

回想先前的章節，你的模型需要一種匹配的棋盤編碼方案。PolicyAgent類可以在構造函數中接受模型和棋盤編碼器。這創造了一個很好的分離。這個PolicyAgent類負責根據模型來選擇落子，並根據其經驗來改變其行爲。但它可以忽略模型結構和棋盤編碼方案的細節。

from dlgo.agent.base import Agent


class PolicyAgent(Agent):

    def __init__(self, model, encoder):
        super().__init__()
        #eras順序模型實例
        self.model = model
        #編碼器
        self.encoder = encoder

要啓動強化學習過程，首先要構造一個棋盤編碼器，然後是一個模型，最後是代理。下面的代碼就顯示了這個過程。 

from dlgo.Encoder.ElevenEncoder import ElevenPlaneEncoder
from keras.models import Sequential
from dlgo.network.LargeLayer import layers
from keras.layers import Dense
from keras.layers import Activation
from dlgo.agent.PolicyAgent.PolicyAgent import PolicyAgent

board_size = 19
encoder = ElevenPlaneEncoder(board_size)
#構建順序神經網絡
model = Sequential()
for layer in layers(encoder.shape()):
    model.add(layer)
# 添加一個輸出層，該層將在返回棋盤上點的概率分佈
model.add(Dense(encoder.num_points()))
model.add(Activation('softmax'))
new_agent = PolicyAgent(model, encoder)

當您使用新創建的模型構造這樣的代理時，Keras將模型權重初始化爲小的隨機值。在這一點上，代理的策略將接近統一的隨機：它會以大致相等的概率選擇任何有效的落子。然後，訓練其模型將爲其決策添加結構。

 9.3.5.實現落子選擇

在開始自我對弈之前，PolicyAgent還需要實現1一個函數：select_move。此函數將類似於DeepLearningAgent中的select_move函數。第一步是將棋盤編碼爲一個張量（一堆矩陣；見附錄A），適合輸入給模型。接下來，你把棋盤的張量輸入到模型中，然後就會得到一個落子概率分佈，之後對分佈進行裁剪，以確保沒有概率一直到1或0。圖9.3說明了這一過程的流程。清單9.12顯示瞭如何實現這些步驟，幾乎和DeepLearningAgent一樣

   # 返回整個棋盤預測概率分佈
    def predict(self, game_state):
        encoded_state = self.encoder.encode(game_state)
        input_tensor = np.array([encoded_state])
        return self.model.predict(input_tensor)[0]

    #裁剪概率分佈
    def clip_probs(original_probs):
        min_p = 1e-5
        max_p = 1 - min_p
        clipped_probs = np.clip(original_probs, min_p, max_p)
        # 確保結果仍然是有效的概率分佈
        clipped_probs = clipped_probs / np.sum(clipped_probs)
        return clipped_probs

    def select_move(self, game_state):
        num_moves = self.encoder.board_width*self.encoder.board_height
        # 獲得預測概率分佈
        move_probs = self.predict(game_state)

        # 裁剪概率分佈
        move_probs = self.clip_probs(move_probs)

        # 把概率轉成一個排序列表(0-360)
        candidates = np.arange(num_moves)
        # 按照落子概率進行採樣，不允許取相同的落子
        ranked_moves = np.random.choice(
            candidates, num_moves, replace=False, p=move_probs)
        # 從最高層開始，找到一個有效的落子，不會減少視野空間
        for point_index in ranked_moves:
            point = self.encoder.decode_point_index(point_index)
            if game_state.is_valid(goboard.Move.play(point)) and \
                    not is_point_true_eye(game_state.board, point, game_state.current_player):
                return goboard.Move.play(point)
        return goboard.Move.pass_turn()

9.4.自我對弈：一個計算機程序該怎麼做？

現在你有了一個能夠完成遊戲的學習代理，你可以開始收集經驗數據。對於圍棋AI來說，這意味着要玩成千上萬的遊戲。本節介紹如何實現這一過程。首先，我們描述了一些數據結構，使處理經驗數據更加方便。接下來，我們將展示如何實現自我對弈驅動程序。

9.4.1.表示經驗數據 

經驗數據包含三個部分：狀態、行動和回報。爲了有效組織這三個部分，您可以創建一個單獨的數據結構，將它們放在一起。

ExperienceBuffer類是一個經驗數據集的最小容器。它有三個屬性：狀態、行動和獎勵。所有這些都被表示爲NumPy數組；您的代理將負責編碼它的狀態和動作作爲數據結構。ExperienceBuffer只是一個容器，用來傳遞數據集。在這種實現中，沒有任何特定的策略梯度學習。在後面的章節中，您可以使用其他強化學習算法來重用這個類。因此，您需要將此類添加到dlgo/rl/experience.py模塊中。 

class ExperienceBuffer:

    def __init__(self, states, actions, rewards):
        self.states = states
        self.actions = actions
        self.rewards = rewards

現在，您有了一個簡單的容器來傳遞經驗數據。你仍然需要一種方法來填充你的經紀人的決定。複雜的是代理人一次只做一個決定，但是直到比賽結束，當你知道誰贏了，它纔會得到獎勵。要解決這個問題，您需要跟蹤當前變化下的所有決定，直到它完成。一種選擇是把這個它的邏輯直接放到代理中，但這會擾亂PolicyAgent的實現。或者，你可以把這個分離成一個獨立的ExperienceCollector對象。

這個ExperienceCollector實現了四種方法：

• begin_episode和complete_episode，這兩種方法被自我遊戲驅動程序調用，以指示一個簡單遊戲的開始和結束。
• record_decision，它被代理調用以指示它選擇的單個操作。
• to_buffer將ExperienceCollector所記錄的所有內容打包並返回ExperienceBuffer。自我對弈驅動程序將在自我遊戲會話結束時調用它。完整的實現如下。

class ExperienceCollector:

    def __init__(self):
        self.states = []
        self.actions = []
        self.rewards = []
        self.current_episode_states = []
        self.current_episode_actions = []

        def begin_episode(self):
            self.current_episode_states = []
            self.current_episode_actions = []

        # 記錄當前的決定和行動
        def record_decision(self, state, action):
            self.current_episode_states.append(state)
            self.current_episode_actions.append(action)

        def complete_episode(self, reward):
            num_states = len(self.current_episode_states)
            # +=用在列表表示連接列表
            self.states += self.current_episode_states
            self.actions += self.current_episode_actions
            # 給遊戲中從episode開始到結束時的每一個動作都分配最後的回報(贏是1，輸是-1)
            self.rewards += [reward for _ in range(num_states)]
            self.current_episode_states = []
            self.current_episode_actions = []

        # 將python列表轉成numpy矩陣，然後返回ExperienceBuffer
        def to_buffer(self):
            return ExperienceBuffer(states=np.array(self.states),
                                    actions=np.array(self.actions),
                                    rewards = np.array(self.rewards))

9.4.2.模擬遊戲

下一步是玩遊戲。您已經在本書中做過兩次這樣的操作：在第3章中的bot_v_bot演示中，以及在第4章實現的蒙特卡洛模擬評估。您可以在這裏使用相同的stimulate_game實現。 

def simulate_game(black_player, white_player,board_size):
    moves = []
    game = GameState.new_game(board_size)
    agents = {
        Player.black: black_player,
        Player.white: white_player,
    }
    while not game.is_over():
        next_move = agents[game.current_player].select_move(game)
        moves.append(next_move)
        game = game.apply_move(next_move)

    print_board(game.board)
    game_result = compute_game_result(game)
    print(game_result)

    return GameRecord(
        moves=moves,
        winner=game_result.winner,
        margin=game_result.winning_margin,
    )

 你也可以用一個自己的副本與自己對弈。除了這種解決方案的簡單性外，還有兩個具體的優點。

首先，強化學習需要兼顧成功和失敗的教訓。想象下你的第一盤棋或與大師對決。作爲一個新手，你將遠遠落後於對手，這時你不可能知道哪裏錯了，而有經驗的棋手可能會犯幾個錯誤，但仍然可以輕鬆獲勝。因此，兩位棋手都不會從比賽中學到很多東西。取而代之的，初學者一開始通常會與其他初學者對局，然後慢慢提升對手水平。同樣的原理也適用於強化學習，當你的AI與自己對弈的時候，它總是會有一個同等水平的對手。

第二，讓你的AI與自己對弈，這樣你花一個AI的時間得到兩場遊戲的經驗。因爲遊戲雙方有同樣的決策過程，你可以從贏方和輸方兩方面學習。因爲你需要進行大量的遊戲來強化學習，因此獲得兩倍的速度是一個很好的方案。

爲了開始自我對弈過程，您需要構造了兩個副本，併爲它們都分配一個ExperienceCollector。每個代理都需要自己的收集器，因爲兩個代理在遊戲結束時會看到不同的回報。清單9.19展示了這個初始化步驟。

遊戲之上強化學習

自我對弈是收集棋盤遊戲經驗數據的一種很好的技術。在其他領域中，您需要單獨構建一個模擬環境來運行您的代理。例如，你想要使用強化學習爲機器人構建控制系統，您需要對機器人將在的物理環境進行詳細的模擬。

如果你想用強化學習進一步試驗，OpenAI Gym（https://github.com/openai/gym）是一個有用的資源。它爲各種棋盤遊戲、視頻遊戲和物理模擬提供了環境。

  # 開始模擬對局
    for i in range(num_games):
        collector1.begin_episode()
        collector2.begin_episode()
        game_record = simulate_game(agent1,agent2,board_size)
        # 黑棋贏了給第一個AI回報1，給第二個AI回報-1
        if game_record.winner == Player.black:
            collector1.complete_epoisode(reward=1)
            collector2.complete_epoisode(reward=-1)
        # 白棋贏了給第一個AI回報-1，給第二個AI回報1
        else:
            collector1.complete_epoisode(reward=-1)
            collector2.complete_epoisode(reward=1)

        experience = combine_experience([collector1,collector2])
        with h5py.File(experience_filename, 'w') as experience_outf:
             experience.serialize(experience_outf)

此時，你已經準備好產生自我對弈遊戲了。下一章將向您展示如何從自我對弈數據中去改進你的機器人。

9.5.摘要 

• 一個代理是一種計算機程序，它能支持完成某項任務。比如，我們的圍棋對弈AI就是一個以贏得圍棋遊戲爲目標的AI。
• 強化學習週期涉及到收集經驗數據，從經驗數據中訓練代理，並評估更新的代理。在一個週期結束時，您期望您的代理的性能有一個小的改進。理想情況下，你可以重複這個週期很多次，從而不斷提高你的代理人。
• 要將強化學習應用於問題，你必須用狀態、行動和回報來描述問題。
• 回報是你控制強化學習行爲的方式。你可以爲你希望你的代理人實現的結果提供積極的回報，爲你想要避免的結果提供消極的回報。
• 一個政策是從給定遊戲狀態作出決策的規則。在圍棋AI中，從給定的棋盤局面去選擇落子的算法是其策略。
• 你可以用神經網絡來制定一個策略，通過將輸出向量視爲可能落子的概率分佈，然後從概率分佈中採樣。
• 當把強化學習應用到遊戲中時，你可以選擇通過自我對弈來體驗數據：你的代理將和自己的副本玩遊戲。 

 

運行其中一局截圖（.是空,o是黑，x是白,結果該局自我對弈白勝）

19  o  o  .  o  o  o  o  .  o  .  o  .  o  .  o  o  o  .  o 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
18  o  o  o  o  o  .  o  o  o  o  o  o  o  o  o  o  o  o  o 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
17  o  o  o  o  o  o  o  o  o  o  x  x  x  o  .  o  o  o  o 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
16  o  .  o  o  .  o  .  o  o  x  x  x  x  o  o  o  o  o  . 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
15  o  o  o  o  o  o  o  o  o  x  x  x  o  o  o  o  .  o  o 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
14  o  o  o  o  o  x  x  x  o  o  x  x  x  x  x  x  o  o  o 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
13  o  .  o  o  x  x  x  x  x  x  x  x  x  x  x  x  o  o  o 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
12  x  o  o  o  o  o  x  x  x  x  x  o  o  o  x  o  o  o  o 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
11  x  x  o  o  x  x  .  x  x  .  x  o  o  o  o  o  o  .  o 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
10  x  x  x  x  .  x  x  x  x  x  x  x  x  o  .  o  o  o  o 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
 9  x  .  x  x  x  x  .  x  x  x  x  x  x  o  o  .  o  .  o 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
 8  x  x  x  x  .  x  x  x  x  .  x  o  o  o  o  o  o  o  o 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
 7  .  x  .  x  x  x  .  x  x  x  x  o  .  o  x  o  o  o  o 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
 6  x  x  x  x  x  x  x  x  x  x  o  o  o  o  x  o  o  o  x 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
 5  x  x  x  x  x  .  x  o  o  o  o  o  x  x  x  x  o  x  x 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
 4  x  .  x  x  .  x  x  o  o  .  o  o  o  o  x  x  x  x  x 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
 3  x  x  .  x  x  x  o  o  o  o  o  o  .  o  o  x  x  x  x 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
 2  .  x  x  x  x  o  o  o  .  o  o  o  o  o  x  .  x  .  x 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
 1  x  x  x  x  o  o  o  o  o  o  o  o  .  o  x  x  x  x  x 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
W+43.5

10局自我對弈後文件保存成experience.h5