從本節開始，我們廢話少說，迅速進入代碼編寫階段。對技術而言“做”永遠是比“講”更好的說，很多用語言講不清楚的道理，看一下代碼自然就明白了。我們要實現的圍棋機器人必須做到以下幾點：

1， 跟蹤當前所下的每一步棋。
2， 跟蹤當前的棋局進展。如果是機器人自我對弈，那么代碼對棋局的跟蹤與人和機器人對弈是對棋局的跟蹤有所不同。
3， 根據當前棋盤局勢，搜索多種可行的下法，并從中評估出最好的走法。
4， 將棋局轉換為可以擁有訓練網絡的數據。

我們從易到難，先解決好小范圍的問題，打好基礎后才能處理更復雜的問題。首先我們要用代碼編制好棋盤，player，落子等對象。首先我們用代碼實現棋手:

import enumclass Player(enum.Enum):black = 1white = 2'''返回對方棋子顏色，如果本方是白棋，那就返回Player.black'''@propertydef other(self):if self == Player.white:return Player.blackelse:return Player.white

上一節我們講過，圍棋棋盤是由多條橫線和豎線交織而成，棋子必須落在橫線和豎線交叉點上，我們用以下代碼表示交叉點：

from collections import namedtupleclass Point(namedtuple('Point', 'row col')):def neghbors(self):'''返回當前點的相鄰點，也就是相對于當前點的上下左右四個點'''return [Point(self.row - 1, self.col),Point(self.row + 1, self.col),Point(self.row, self.col - 1),Point(self.row, self.col + 1),]

這里我們使用python3的語言特性增加可讀性，Point類其實包含兩個整形成員，分別命名為row和col，我們可以使用point.row和point.col來訪問兩個成員，如果不使用nametuple，那么我們得通過point[0]，piont[1]來訪問兩個成員，如此可讀性就大大降低。

接下來我們需要用代碼來表示“落子”：

import copyclass Move():def __init__(self, point = None, is_pass = False, is_resign = False):assert(point is not None) ^is_pass ^is_resignself.point = point#是否輪到我下self.is_play (self.pint is not None)self.is_pass = is_passself.is_resign = is_resign@classmethoddef play(cls, point):return Move(point = point)@classmethod#讓對方繼續下def pass_turn(cls):return move(is_pass = True)@classmethod#投子認負def resign(cls):return move(is_resign = True)

在圍棋中，“落子”分三種情況，一種是把棋子放到某個點；一種是放棄下子，讓對方繼續下，類似于撲克中的“大”，“過”；第三是投子認負，我們上面代碼中都對應了三種情況。

上面代碼只是擁有表示下棋時的一下基本概念，并不包含邏輯，接下來我們要編寫圍棋的規則及邏輯代碼。首先要做的是棋盤，棋盤在每次落子之后它要檢測是否有對方棋子被吃，它要檢測相鄰棋子的所有自由點是否全部堵上，由于很可能有很多個棋子相鄰在一起，因此這一步或許或比較耗時，我們先用代碼表示相鄰在一起的多個棋子：

class GoString():def __init__(self, color, stones, liberties):self.color = colorself.stones = set(stones)self.liberties = set(liberties)def remove_liberty(self, point):self.liverties.remove(point)def add_liberty(self, point):self.liberties.add(point)def merged_with(self, go_string):#落子之后，兩片相鄰棋子可能會合成一片'''假設*代表黑棋，o代表白棋，x代表沒有落子的棋盤點，當前棋盤如下：x x x x x xx * x! * o *x x x * o xx x * x o xx x * o x x注意看帶!的x，如果我們把黑子下在那個地方，那么x!左邊的黑棋和新下的黑棋會調用當前函數進行合并，同時x!上方的x和下面的x就會成為合并后相鄰棋子共同具有的自由點。同時x!原來屬于左邊黑棋的自由點，現在被一個黑棋占據了，所以下面代碼要把該點從原來的自由點集合中去掉'''assert go_string.color == self.colorcombined_stones = self.stones | go_string.stonesreturn GoString(self.color, combined_stones, (self.liberties | go_string.liberties) - combined_stones)@propertydef num_liberties(self):return len(self.liberties)def __eq__(self, other):return isinstance(other, GoString) and self.color == other.color and self.stones == other.stones and self.liberties == other.liberties

上面代碼中的merge_with函數不好理解，必須要仔細理解上面注釋才好理解代碼邏輯,同時我們可以借助下圖來理解merge_with函數的邏輯：

試想在第二行兩個分離的黑棋中落一個黑棋，那么左邊單個黑棋和右邊兩個黑棋就會連成一片，左邊黑棋與落在中間黑棋連接成片時，它的自由點集合要減去中間落入的黑棋，同理右邊兩個黑棋的自由點也要減去落在中間黑棋所占據的位置，這就是為何要執行語句(self.liberties | go_string.liberties) - combined_stones。

接下來我們使用代碼實現棋盤：

class Board():def __init__(self, num_rows, num_cols):self.num_rows = num_rowsself.num_cols = num_colsself._grid = {}def place_stone(self, player, point):#確保位置在棋盤內assert self.is_on_grid(point)#確定給定位置沒有被占據assert self._grid.get(point) is Noneajecent_same_color = []adjacent_oppsite_color = []liberties = []for neighbor in point.neighbors():#判斷落子點上下左右的鄰接點情況if not self.is_on_grid(neighbor):continueneighbor_string = self._grid.get(neighbor)if neighbor_string is None:#如果鄰接點沒有被占據，那么就是當前落子點的自由點liberties.append(neighbor)elif neighbor_string.color == player:if neighbor_string not in adjacent_same_color:#記錄與棋子同色的連接棋子adjacent_same_color.append(neighbor_string)else:if neighbor_string not in ajacent_opposite_color:#記錄落點鄰接點與棋子不同色的棋子adjacent_opposite_color.append(neighbor_string)#將當前落子與棋盤上相鄰的棋子合并成一片 new_string = GoString(player, [point], liberties)for same_color_string in adjacent_same_color:new_string = new_string.merged_with(same_color_string)for new_string_point in new_string.stones:#訪問棋盤某個點時返回與該點棋子相鄰的所有棋子集合self._grid[new_string_point] = new_stringfor other_color_string in adjacent_opposite_color:#當該點被占據前，它屬于反色棋子的自由點，占據后就不再屬于反色棋子自由點other_color_string.remove_libertiy(point)for other_color_string in adjacent_opposite_color:#如果落子后，相鄰反色棋子的所有自由點都被堵住，對方棋子被吃掉if other_color_string.num_liberties == 0:self._remove_string(other_color_string)def is_on_grid(self, point):return 1 <= point.row <= self.num_rows and 1 <= point.col <= self.num_colsdef get(self, point):string = self._grid.get(point)if string is None:return Nonereturn string.colordef get_go_string(self, point):string = self._grid.get(point)if string is None:return Nonereturn stringdef _remove_string(self, string):#從棋盤上刪除一整片連接棋子for point in string.stones:for neighbor in point.neighbors():neighbor_string = self._grid.get(neighbor)if neighbor_string is None:continueif neigbor_string is not string:neighbor_string.add_liberty(point)self._grid[point] = None

這里我們需要解釋_remove_string的邏輯。如下圖：

當我們在像右邊落入黑子后，中間被包圍的白子被吃掉后需要從棋盤上拿開。此時我們需要把被拿走棋子所在的點設置成未被占據狀態，同時查找改點上下左右四邊的棋子片，為這些棋片增加一個自由點。

落子和棋盤都完成了，由于每次落子到棋盤上后，棋局的狀態會發生變化，接下來我們完成棋盤狀態的檢測和落子法性檢測，狀態檢測會讓程序得知以下信息：各個棋子的擺放位置；輪到誰落子；落子前的棋盤狀態，以及最后一次落子信息，以及落子后棋盤的狀態變化：

class GameState():def __init__(self, board, next_player, previous, move):self.board = boardself.next_player = next_playerself.previous_state = previousself.last_move = movedef apply_move(self, move):if move.is_play:next_board = copy.deecopy(self.board)next_board.place_stone(self.next_player, move.point)else:next_board = self.boardreturn GameState(next_board, self.next_player.other, self, move)@classmethoddef new_game(cls, board_size):if isinstance(board_size, int):board_size = (board_size, board_size)board = Board(*board_size)return GameState(board, Player.black, None, None)def is_over(self):if self.last_move is None:return Falseif self.last_move.is_resign:return Truesecond_last_move = self.previous_state.last_moveif second_last_move is None:return False#如果兩個棋手同時放棄落子，棋局結束return self.last_move.is_pass and second_lass_move.is_pass

接下來我們需要確定，落子時是否合法。因此我們需要確定三個條件，落子的位置沒有被占據；落子時不構成自己吃自己；落子不違反ko原則。第一個原則檢測很簡單，我們看看第二原則：

我們看上圖，三個黑棋連片只有一個自由點，那就是小方塊所在位置。但不管黑棋要不要堵住那個店，三個黑子終究要被吃掉，因此黑棋不能在小方塊所在位置落點，因為落點后，四個黑棋連片，但卻再也沒有自由點，于是黑棋下在小方塊位置，反而被對方吃的更多，這就叫自己吃自己，絕大多數圍棋比賽都不允許這樣的下法。

當時下面請看就不同了：

當黑棋下在小方塊處，它能把中間兩個白棋吃掉，因此就不算是自己吃自己，因為中間兩個白棋拿掉后，黑棋就會有自由點。因此程序必須在落子結束，拿掉所有被吃棋子后，才能檢查該步是否形成自己吃自己：

def is_move_self_capture(self, player, move):if not move.is_play:return Falsenext_board = copy.deepcopy(self.board)#先落子，完成吃子后再判斷是否是自己吃自己next_board.place_stone(player, move.point)new_string = next_board.get_go_string(move.point)return new_sting.num_liberties == 0

接下來我們完成ko的檢測，也就是對方落子后，你的走棋方式不能把棋盤恢復到對方落子前的局面。由于我們上面實現的GameState類保留了落子前狀態，因此當有新落子后，我們把當前狀態跟以前狀態比對，如果發現有比對上的，那表明當前落子屬于ko，代碼實現如下：

@propertydef situation(self):return (self.next_player, self.board)def does_move_violate_ko(self, player, move):if not move.is_play:return Falsenext_board = copy.deepcopy(self.board)next_board.place_stone(player, move.point)next_situation = (player.other, next_board)past_state = self.previous_state#判斷Ko不僅僅看是否返回上一步的棋盤而是檢測是否返回以前有過的棋盤狀態while past_state is not None:if past_state.situtation == next_situtation:return Truereturn Falsedef is_valid_move(self, move):if self.is_over():return Falseif move.is_pass or move.is_resign:return Truereturn (self.board.get(move.point) is None and not self.is_move_self_capture(self.next_player, move) andnot self.does_move_violate_ko(self.next_player, move))

我們上面實現的does_move_violate_ko效率比較差，因為每下一步棋，我們就得執行該函數，它會搜索過往所有棋盤狀態進行比較，如果當前已經下了幾百手，那么每下一步，它就得進行幾百次比對，因此效率會非常慢，后面我們會有辦法改進它的效率。

最后我們需要預防機器人下棋時，把自己的棋眼給堵死，例如下面棋局：

如果機器人下的是白棋，那么它不能自己把A,B點給堵上，因為堵上后，黑棋會把所有白棋吃掉，因此我們必須增加代碼邏輯檢測這種情況。我們隊棋眼的定義是，所有的鄰接點都被己方棋子占據的位置,并且該棋子四個對角線位置中至少有3個被己方棋子占據，如果棋子落子棋盤邊緣，那么我們要求它所有對角線位置都被己方棋子占據，實現代碼如下：

def is_point_an_eye(board, point, color):if board.get(point) is not None:return Falsefor neighbor in point.neighbors():#檢測鄰接點全是己方棋子if board.is_on_grid(neighbor):neighbor_color = board.get(neighbor)if neighbor_color != color:return False#四個對角線位置至少有三個被己方棋子占據 friendly_corners = 0off_board_corners = 0corners = [Point(point.row - 1, point.col - 1),Point(point.row - 1, point.col + 1),Point(point.row + 1, point.col - 1),Point(point.row + 1, point.col + 1)]for corner in corners:if board.is_on_grid(corner):corner_color = board.get(corner)if corner_color == color:friedly_corner += 1else:off_board_corners += 1if off_board_corners > 0:return off_board_corners + friendly_corners == 4return friendly_corners >= 3

有了上面代碼基礎后，我們就可以實現自我博弈圍棋機器人，那將是下一節的內容。

更詳細的講解和代碼調試演示過程，請點擊鏈接

更多技術信息，包括操作系統，編譯器，面試算法，機器學習，人工智能，請關照我的公眾號：

總結

以上是生活随笔為你收集整理的从零开始再造打爆李世石的AlphaGo:快速构建棋盘和围棋规则的全部內容，希望文章能夠幫你解決所遇到的問題。

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