棋类游戏中的智能决策 ——蒙特卡洛树搜索(MCTS)算法解析

原创

已于 2025-05-05 16:34:51 修改 · 2.6k 阅读

标签

#游戏 #算法 #random #numpy #matplotlib

于 2025-05-05 14:45:00 首次发布

该文章已生成可运行项目，

在人工智能领域，蒙特卡洛树搜索（Monte Carlo Tree Search，MCTS）是一种强大的决策制定算法，尤其适用于复杂的游戏和规划问题。本文将深入浅出地介绍MCTS算法的原理、实现步骤，并通过井字游戏的实例来展示其应用。

一、背景知识

在棋类游戏中，人工智能的目标是找到最优策略以击败对手。传统的 Minimax 算法在处理高分支因子的游戏如围棋时表现不佳，而蒙特卡洛树搜索（MCTS）凭借其独特的优势脱颖而出。MCTS 不需要像 Minimax 那样遍历整个游戏树，而是通过随机模拟和统计分析，集中精力探索最有希望的分支，从而在复杂的棋类游戏中实现有效的决策。

1.1 MCTS算法简介

MCTS是一种基于采样的搜索算法，它结合了蒙特卡洛方法和树搜索策略，能够在大规模的决策空间中有效地寻找最优解。其核心思想是通过随机模拟来估计每个可选行动的价值，并利用这些信息逐步构建搜索树，以指导未来的决策。

1.2 应用场景

MCTS在众多领域都有广泛应用，特别是在棋类游戏、机器人控制和自动规划等领域表现出色。例如，AlphaGo利用MCTS在围棋中击败了世界冠军，展示了其强大的决策能力。

二、MCTS算法原理

2.1 核心思想

MCTS 算法的核心在于构建一个搜索树来表示游戏状态的可能演变。树中的每个节点代表特定的棋盘位置，叶子节点代表终端游戏状态（胜负或平局）。算法通过不断地迭代，每次迭代包括四个主要步骤：选择、扩展、模拟和反向传播。

2.2 算法步骤

2.2.1 选择（Selection）

从根节点开始，依据一定策略（如UCT公式）选择最有潜力的子节点，直到达到一个尚未完全展开的节点。UCT（Upper Confidence Bound for Trees）公式如下：

$\frac{W_i}{N_i} + C \sqrt{\frac{\ln N_p}{N_i}}$

其中， $W_i$ 是节点i的胜利次数， $N_i$ 是节点i的访问次数， $N_p$ 是父节点的访问次数，C是探索参数。

2.2.2 扩展（Expansion）

在未完全展开的节点处添加一个新的子节点，代表一个可能的动作。

2.2.3 模拟（Simulation）

从新扩展的节点开始，进行一次随机的游戏模拟，直到游戏结束，以此估计该路径的结果。

2.2.4 反向传播（Backpropagation）

根据模拟结果更新沿途所有节点的信息，包括访问次数和胜利次数等统计数据。

三、代码实现与应用

3.1 井字游戏中的MCTS实现

以下是一个使用Python实现的井字游戏MCTS算法示例：

import math
import random
from copy import deepcopy

class GameState:
    def __init__(self, board=None, player=1):
        self.board = board or [0] * 9  # 空格:0, X:1, O:-1
        self.player = player  # 当前玩家 (1 表示 X, -1 表示 O)

    def get_possible_moves(self):
        return [i for i, v in enumerate(self.board) if v == 0]

    def make_move(self, move):
        new_board = self.board.copy()
        new_board[move] = self.player
        return GameState(new_board, -self.player)

    def is_terminal(self):
        return self.get_winner() is not None or not self.get_possible_moves()

    def get_winner(self):
        winning_combinations = [
            (0,1,2), (3,4,5), (6,7,8),  # 横向
            (0,3,6), (1,4,7), (2,5,8),  # 纵向
            (0,4,8), (2,4,6)             # 对角线
        ]
        for combo in winning_combinations:
            total = sum(self.board[i] for i in combo)
            if total == 3:
                return 1  # X 胜
            if total == -3:
                return -1  # O 胜
        return None  # 无胜者

class Node:
    def __init__(self, state, parent=None, move=None):
        self.state = state
        self.parent = parent
        self.children = {
   
   }  # key: move, value: Node
        self.visits = 0
        self.wins = 0
        self.move = move  # 导致该节点的动作

    def is_fully_expanded(self):
        return len(self.children) == len(self.state.get_possible_moves())

    def best_child(self, c_param=1.4):
        choices_weights = [
            (child.wins / child.visits + c_param * math.sqrt(math.log(self.visits) / child.visits), child)
            for child in self.children.values() if child.visits > 0
        ]
        return max(choices_weights, key=lambda x: x[0])[1]

    def expand(self):
        tried_moves = set(self.children.keys())
        possible_moves = set(self.state.get_possible_moves()) - tried_moves
        move = random.choice(list(possible_moves))
        new_state = self.state.make_move(move)
        child_node = Node(new_state, self, move)
        self.children[move] = child_node
        return child_node

def tree_policy(node):
    while not node.state.is_terminal():
        if not node.is_fully_expanded():
            return node.expand()
        else:
            node = node.best_child()
    return node

def default_policy(state):
    current_state = deepcopy(state)
    while not current_state.is_terminal():
        possible_moves = current_state.get_possible_moves()
        move = random.choice(possible_moves)
        current_state = current_state.make_move(move)
    winner = current_state.get_winner()
    if winner == 1:
        return 1
    elif winner == -1:
        return 0
    else:  # 平局
        return 0

def backup(node, result):
    while node is not None:
        node.visits += 1
        if result == 1:  # 当前玩家胜利
            node.wins += 1
        elif result == 0:  # 平局或对方玩家胜利
            node.wins += 0
        node = node.parent

def mcts(root_state, iterations=1000):
    root_node = Node(root_state)
    for _ in range(iterations):
        leaf = tree_policy(root_node)
        simulation_result = default_policy(leaf.state)
        backup(leaf, simulation_result)
    return root_node.best_child(c_param=0).move  # 最佳移动

# 示例：使用MCTS进行一次井字游戏决策
if __name__ == "__main__":
    initial_state = GameState()
    best_move = mcts(initial_state, iterations=1000)
    print(f"推荐的最佳移动位置: {
     
     best_move}")

3.2 代码解释

GameState类：用于表示游戏状态，包括获取可能的移动、执行移动、判断游戏是否结束以及获取胜者等方法。
Node类：表示搜索树中的节点，包含游戏状态、父节点、子节点、访问次数和胜利次数等属性。
tree_policy函数：实现选择和扩展步骤，从根节点开始选择最有潜力的子节点，直到达到未完全展开的节点。
default_policy函数：实现模拟步骤，从当前状态开始进行随机模拟，直到游戏结束。
backup函数：实现反向传播步骤，根据模拟结果更新节点的访问次数和胜利次数。
mcts函数：主函数，执行多次迭代，每次迭代调用上述步骤，最终返回最佳移动。

四、可视化增强

为了更好地展示MCTS算法在井字游戏中的应用，可以添加棋盘的可视化功能。使用matplotlib库来绘制棋盘，以便更直观地观察游戏状态的变化。

import math
import random
from copy import deepcopy
import matplotlib.pyplot as plt
import numpy as np

# 解决中文显示问题（如需要）
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False

class GameState:
    def __init__(self, board=None, player=1):
        self.board =<