人工智能初探3：围棋ai篇1（含代码）

universe_code

已于 2025-03-04 23:20:36 修改

阅读量1.3k

点赞数 20

分类专栏：围棋ai 文章标签：人工智能

于 2025-02-03 18:20:28 首次发布

本文链接：https://blog.csdn.net/universe_code/article/details/145431869

版权

围棋ai 专栏收录该内容

2 篇文章

订阅专栏

1.发展历程

围棋AI的发展史可以追溯到20世纪60年代，当时最早的围棋AI研究集中在日本。下棋的计算机程序开始出现，但它们的水平很低，无法与人类棋手竞争。

在20世纪70年代和80年代，围棋AI的研究取得了一些进展。首先，研究人员开始使用更复杂的搜索算法，如Alpha-Beta剪枝，以改进计算机程序的下棋水平。然而，由于围棋的复杂性和搜索空间的巨大，围棋AI仍然无法与顶级人类棋手匹敌。

进入21世纪后，围棋AI的发展迎来了重大突破。2006年，IBM的Deep Blue在国际象棋领域击败了世界冠军卡斯帕罗夫，这也启发了研究人员使用深度学习技术来提升围棋AI的水平。

2016年，Google的AlphaGo在与世界冠军李世石的五番棋比赛中4比1取胜，这是围棋AI历史上的一次重大突破。AlphaGo使用了深度神经网络和蒙特卡洛树搜索算法，大大提高了其下棋水平。

之后，围棋AI的发展迅速。2017年，AlphaGo Zero在不使用人类棋谱的情况下，仅通过自我博弈训练，就达到了超越AlphaGo的水平。2018年，DeepMind推出了AlphaZero，它能够自我学习和超越多种棋类游戏，包括围棋、国际象棋和日本将棋。

围棋AI的发展不仅在围棋领域取得了巨大成功，还对其他领域的人工智能研究产生了深远影响。围棋AI的成功证明了深度学习和强化学习等技术的潜力，也加速了人工智能的发展和应用。

2.实现思路

1.围棋棋盘表示

class GoBoard:
    def __init__(self, size=19):
        self.size = size
        self.board = [[0] * size for _ in range(size)]  # 0: empty, 1: black, 2: white

    def place_stone(self, x, y, player):
        if self.board[x][y] == 0:
            self.board[x][y] = player
            return True
        return False

    def get_legal_moves(self):
        moves = []
        for i in range(self.size):
            for j in range(self.size):
                if self.board[i][j] == 0:
                    moves.append((i, j))
        return moves

    def is_game_over(self):
        # 这里可以添加判断游戏结束的逻辑
        return False

2.蒙特卡洛树搜索MCTS
MCTS是一种用于决策的算法，特别适合围棋这种复杂的游戏。MCTS通过模拟大量的随机对局来评估每个可能的走法。

import random

class Node:
    def __init__(self, parent=None, move=None, board=None):
        self.parent = parent
        self.move = move
        self.board = board
        self.children = []
        self.wins = 0
        self.visits = 0
        self.untried_moves = board.get_legal_moves()

    def select_child(self):
        # 使用UCT算法选择子节点
        s = sorted(self.children, key=lambda c: c.wins / c.visits + sqrt(2 * log(self.visits) / c.visits))[-1]
        return s

    def expand(self):
        move = self.untried_moves.pop()
        new_board = self.board.copy()
        new_board.place_stone(*move, self.board.current_player)
        child_node = Node(parent=self, move=move, board=new_board)
        self.children.append(child_node)
        return child_node

    def update(self, result):
        self.visits += 1
        self.wins += result

    def simulate(self):
        # 随机模拟对局
        current_board = self.board.copy()
        while not current_board.is_game_over():
            moves = current_board.get_legal_moves()
            if not moves:
                break
            move = random.choice(moves)
            current_board.place_stone(*move, current_board.current_player)
        return current_board.get_result()

    def copy(self):
        new_board = GoBoard(self.size)
        new_board.board = [row[:] for row in self.board]
        return new_board

    def get_result(self):
        # 这里可以添加计算胜负的逻辑
        return 0

3.MCTS主循环(包括选择、扩展、模拟和反向传播)

from math import sqrt, log

def mcts(root, iterations):
    for _ in range(iterations):
        node = root
        # 选择
        while node.untried_moves == [] and node.children != []:
            node = node.select_child()
        # 扩展
        if node.untried_moves != []:
            node = node.expand()
        # 模拟
        result = node.simulate()
        # 反向传播
        while node is not None:
            node.update(result)
            node = node.parent
    return sorted(root.children, key=lambda c: c.visits)[-1].move

4.主程序

def main():
    board = GoBoard()
    current_player = 1  # 1: black, 2: white
    while not board.is_game_over():
        if current_player == 1:
            # AI的回合
            root = Node(board=board)
            move = mcts(root, 1000)  # 1000次模拟
            board.place_stone(*move, current_player)
        else:
            # 玩家的回合
            x, y = map(int, input("Enter your move (x y): ").split())
            board.place_stone(x, y, current_player)
        current_player = 3 - current_player  # 切换玩家
    print("Game over")

if __name__ == "__main__":
    main()

3.解释

棋盘表示：GoBoard类表示围棋棋盘，提供了放置棋子、获取合法走法、判断游戏是否结束等功能。
MCTS节点：Node类表示MCTS树中的一个节点，包含了父节点、走法、棋盘状态、子节点、胜利次数、访问次数等信息。
MCTS算法：mcts函数实现了MCTS的主循环，包括选择、扩展、模拟和反向传播四个步骤。
主程序：main函数实现了简单的围棋对局，AI使用MCTS算法进行决策，玩家通过输入坐标来下棋。

4.优化思路

神经网络模型设计

升级步骤概览

定义神经网络模型：输入棋盘状态，输出策略（走法概率）和值（胜率评估）。
修改MCTS：用神经网络指导搜索过程（替代随机模拟）。
训练神经网络：通过自我对弈生成数据，进行监督学习和强化学习。
整合完整系统：将神经网络与MCTS结合。

1. 神经网络模型设计（使用PyTorch）

import torch
import torch.nn as nn
import torch.nn.functional as F

class GoNet(nn.Module):
    def __init__(self, input_channels=5, board_size=19):
        super(GoNet, self).__init__()
        # 输入通道：当前玩家棋子、对手棋子、气、历史状态等（这里简化为3通道）
        self.conv1 = nn.Conv2d(input_channels, 64, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(64, 64, kernel_size=3, padding=1)
        self.conv3 = nn.Conv2d(64, 64, kernel_size=3, padding=1)
        
        # 策略头（预测走法概率）
        self.policy_conv = nn.Conv2d(64, 2, kernel_size=1)
        self.policy_fc = nn.Linear(2 * board_size**2, board_size**2)
        
        # 价值头（预测胜率）
        self.value_conv = nn.Conv2d(64, 1, kernel_size=1)
        self.value_fc1 = nn.Linear(board_size**2, 64)
        self.value_fc2 = nn.Linear(64, 1)

    def forward(self, x):
        # 输入x形状: [batch, channels, height, width]
        x = F.relu(self.conv1(x))
        x = F.relu(self.conv2(x))
        x = F.relu(self.conv3(x))
        
        # 策略输出
        p = F.relu(self.policy_conv(x))
        p = p.view(p.size(0), -1)  # 展平
        p = self.policy_fc(p)
        p = F.softmax(p, dim=1)  # 走法概率分布
        
        # 价值输出
        v = F.relu(self.value_conv(x))
        v = v.view(v.size(0), -1)
        v = F.relu(self.value_fc1(v))
        v = torch.tanh(self.value_fc2(v))  # 范围[-1, 1]，表示当前玩家胜率
        
        return p, v

2. 修改MCTS节点（神经网络指导搜索）

class NeuralNode(Node):
    def __init__(self, parent=None, move=None, board=None, net=None):
        super().__init__(parent, move, board)
        self.net = net  # 神经网络模型
        self.policy = None  # 策略概率
        self.value = None   # 价值评估
        
    def expand(self):
        # 使用神经网络预测策略概率
        if self.policy is None:
            board_tensor = self._board_to_tensor()
            with torch.no_grad():
                policy_probs, value = self.net(board_tensor)
            self.policy = policy_probs.cpu().numpy().flatten()
            self.value = value.item()
        
        # 按策略概率选择未尝试的走法
        legal_moves = self.untried_moves
        move_probs = [self.policy[move[0]*self.board.size + move[1]] for move in legal_moves]
        total = sum(move_probs)
        if total == 0:  # 防止除零
            move_probs = [1/len(legal_moves)] * len(legal_moves)
        else:
            move_probs = [p/total for p in move_probs]
        
        # 选择概率最高的走法扩展
        idx = np.argmax(move_probs)
        move = legal_moves.pop(idx)
        new_board = self.board.copy()
        new_board.place_stone(*move, self.board.current_player)
        child = NeuralNode(parent=self, move=move, board=new_board, net=self.net)
        self.children.append(child)
        return child

    def _board_to_tensor(self):
        # 将棋盘转换为神经网络的输入张量
        # 这里简化为3通道：当前玩家、对手、空点
        board_tensor = np.zeros((3, self.board.size, self.board.size))
        for i in range(self.board.size):
            for j in range(self.board.size):
                if self.board.board[i][j] == self.board.current_player:
                    board_tensor[0][i][j] = 1
                elif self.board.board[i][j] != 0:
                    board_tensor[1][i][j] = 1
                else:
                    board_tensor[2][i][j] = 1
        return torch.FloatTensor(board_tensor).unsqueeze(0)  # 添加batch维度

3. 修改MCTS主循环

def neural_mcts(root, iterations, c_puct=1.0):
    for _ in range(iterations):
        node = root
        # 选择阶段（使用PUCT算法）
        while node.children:
            # PUCT公式：argmax(Q + U)
            puct_scores = [
                (child.wins / child.visits) + c_puct * child.policy * sqrt(node.visits) / (child.visits + 1)
                for child in node.children
            ]
            node = node.children[np.argmax(puct_scores)]
        
        # 扩展和评估
        if not node.board.is_game_over():
            node.expand()
        
        # 反向传播价值评估（而非模拟结果）
        value = node.value if node.value is not None else 0
        while node is not None:
            node.visits += 1
            node.wins += value
            node = node.parent
    return max(root.children, key=lambda c: c.visits).move

4. 训练神经网络

监督学习（使用人类棋谱）

def train_supervised(net, dataset, epochs=10):
    optimizer = torch.optim.Adam(net.parameters(), lr=0.001)
    for epoch in range(epochs):
        for board_state, policy_target, value_target in dataset:
            optimizer.zero_grad()
            policy_pred, value_pred = net(board_state)
            loss_policy = F.cross_entropy(policy_pred, policy_target)
            loss_value = F.mse_loss(value_pred, value_target)
            total_loss = loss_policy + loss_value
            total_loss.backward()
            optimizer.step()

强化学习（自我对弈）

def self_play(net, num_games=100):
    for _ in range(num_games):
        board = GoBoard()
        memory = []
        while not board.is_game_over():
            root = NeuralNode(board=board, net=net)
            move = neural_mcts(root, iterations=200)
            board.place_stone(*move, board.current_player)
            # 保存训练数据（状态、MCTS策略、胜负结果）
            memory.append((root._board_to_tensor(), root.policy, 0))
        # 根据最终胜负更新value标签
        result = board.get_result()
        for data in memory:
            data[2] = result
        train_supervised(net, memory)

5. 完整系统整合

def main():
    # 初始化神经网络
    net = GoNet()
    # 加载预训练权重（如果有）
    # net.load_state_dict(torch.load("go_net.pth"))
    
    # 自我对弈训练
    self_play(net, num_games=1000)
    
    # 与AI对弈
    board = GoBoard()
    while not board.is_game_over():
        root = NeuralNode(board=board, net=net)
        move = neural_mcts(root, iterations=200)
        board.place_stone(*move, board.current_player)
        print(f"AI placed at {move}")
        # 玩家输入...