uct博弈算法

最新推荐文章于 2024-05-27 15:59:32 发布
最新推荐文章于 2024-05-27 15:59:32 发布
阅读量5.1k 收藏 41
点赞数 11
分类专栏： 算法专栏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sanzhnag/article/details/108738177
版权

Upper Confidence Bound Apply to Tree，即ucb公式应用于蒙特卡洛搜索树

前段时间用这个算法参加了计算机博弈比赛，写的很糙，以为要爆炸，没想到效果还不错。
先简单介绍一下标题的几个名词，不了解的同学想闹明白的话自行查阅相关资料。

蒙特卡洛算法

理论基础是大数定律，多次数重复模拟的各种结果的概率接近于真实概率，模拟次数越多越接近。就像那个用多个随机点求圆的面积的方法。

ucb公式

ucb值可以理解为这条路的预期价值，价值由两个部分来组成。
该节点的ucb值 = 对该节点模拟得来的平均收益 + 该节点渴望被模拟的欲望
很明显，节点被拜访的相对次数越少，欲望就越强，为的就是不放过有潜在价值的节点。
（凭什么对别人那么好，拜访那么多次？就因为第一次拜访我就让你失望了吗？就这？就再也不相信我了？）
在这里插入图片描述
xj就是平局收益，(k是常数，一般就是1)，nj是当前节点被访问次数，n是当前节点的父节点的访问次数。为什么要写成这样俺也不知道，但已经被证明了这样效果最佳。

uct算法

uct算法主要有四个步骤：选择、模拟、扩展、更新

先举个不用树结构的uct算法吧（呃，这样应该就不叫uct了，应该叫ucb算法？）。总之就是只用一层孩子节点，先理解一下原理。

干说说不出个一二三来，网上清一色拿多臂赌博机举的例子，我拿井字棋举个例子吧（默认大家都知道规则），好比我们是’X’，局面如下图，该我们走子了。
_ X O
X _ O
_ O _
首先我们把当前局面状态拿出来作为根节点，现在我们有四条路可以走，那就从根节点衍生出四个子节点，每个节点对应一条走法。

刚开始并不知道这几条路哪个好，那就先认为全部走法的价值都很高（给所有孩子都赋一个无限大的ucb值），选择孩子中ucb值最大的一个（刚开始都是无限大，但后边会变），对其进行模拟（由电脑随机走子至终局），同时本身拜访次数也加一，它的父节点，这里也是根节点的拜访次数也加一，这里代表总拜访次数，用来求节点被模拟的欲望。模拟是随机模拟，可以模拟多局，得到一个平均收益。然后重新计算该节点的ucb值（肯定比无限大小了）。

我们每次都从根节点开始选ucb值最大的孩子，对它进行模拟，更新拜访次数，并得到一个新的ucb值。电脑的运行速度是很快的，虽然是随机模拟，但大数定律是跑不了的，最终我们选择ucb值最大的那条路。

现在加上树结构说一下uct算法。

大家可能有个疑问，对于上边的井字棋，其实可以直接用树结构直接把所有情况全写出来，这样不是更简单明了？为什么不这样呢？因为一般的博弈问题，像五子棋、围棋等，用树把所有情况写到底是不现实的，单一个围棋都算到世界末日了（可以搜一下）。因此一个比较好的办法就是，挑价值比较高的走法，对它进行更深层次的搜索。

深层次树结构有什么好处？
对一般博弈问题来说，如果只生成一层孩子，也许离终局还有很远，还要走n多步，而且我们的时间有限，随机模拟次数也有限，这种局面下大数定律就有点招呼不住了。uct的思想就是挖掘深层的路线，对其中表现好的（ucb值高的）进行投资（花时间对其进行模拟），而不是把时间和资源浪费在低层次的无脑模拟上。

选择、扩展、模拟、反向传播

选择：从根节点开始，计算所有孩子的ucb值，并选择其中ucb值最大的，直到到达叶子节点。

模拟：以此局面为基础随机走子模拟至终局。

扩展：若上一步选择得到的叶子节点已经被模拟过了，则往下扩展，即生孩子，反之对其进行模拟。

更新：更新模拟收益和拜访次数，不仅自己，所有祖宗都要更新，为了正确计算各个节点的ucb值。完事儿之后再从第一步选择开始，直到时间或预设次数结束。

最后我们就走第一层孩子中ucb值最大的那条路。

个人粗浅理解，可能有纰漏，欢迎补充-v-

糟糕的枣糕
关注
  • 11
    点赞
  • 踩
  • 41
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
UCT（信心上限树算法）解四子棋问题——蒙特卡罗法模拟人机博弈
子追的专栏
05-28 2万+
虽说UC
UCT算法
热门推荐
大菜包
04-26 1万+
UCT算法
蒙特卡洛树搜索python实现
最新发布
qq_63670969的博客
05-27 1186
蒙特卡洛树搜索的python实现，你看懂它的最后一篇文章！
上限置信度区间算法(UCT)
weixin_41656557的博客
04-25 5692
算法来源文章《Bandit based Monte-Carlo Planning》，06年的ECML。建议想做游戏人机玩家的同学看看。 1.多臂老虎机 多臂老虎机问题，简单来说，我有很多个老虎机，虽然都是老虎机但它们的中奖率采取的是不同的概率分布，现在我希望在有限次的摇臂过程中，获得最大的收益，我该怎么做呢？ 最简单的想法肯定是，我对每一个老虎机都摇N次，根据大数定律，频率最终会等于概率。然后我就...
蒙特卡洛树搜索算法（UCT）: 一个程序猿进化的故事
weixin_30725467的博客
10-26 829
前言： 本文是根据的文章Introduction to Monte Carlo Tree Search by Jeff Bradberry所写。 Jeff Bradberry还提供了一整套的例子，用python写的。 board game server board game client Tic Tac Toe board AI implementation of Tic Tac Toe 阿袁工作...
围棋博弈程序的实现与思考（3）——UCT算法
coolsooner
08-28 1493
我们已经知道UCB算法能够更快地找到靠谱的着手点，续上一篇的问，能不能再优化？ 首先要知道的是，为什么UCB算法比盲目的蒙特卡罗局面评估收敛得更快？我的理解，是因为在算法执行的过程中，UCB算法能不断根据之前的结果调整策略，选择优先评估哪一个可下点。其实这是一种在线的机器学习策略。对于上一篇提到过的多臂匪徒问题，可以用UCB算法很好地解决。对于围棋博弈问题而言，UCB算法相比于朴...
计算机博弈点格棋规则,点格棋博弈中UCT算法的研究与实现
weixin_35403151的博客
07-26 1696
点格棋博弈中UCT算法的研究与实现【摘要】：2016年3月谷歌AlphaGo击败世界围棋冠军李世石九段,使人工智能、机器博弈再次成为大众焦点。人工智能是计算机科学的重要研究方向,主要研究用机器来模拟和执行人脑的智力功能,开发相关的理论和技术,从而达到让机器可以能像人一样进行学习、思考、判断等各种脑力活动的目标。机器博弈因使用计算机解决博弈问题而得名,它将博弈思想和计算机科学相融合,希望计算机能像人...
C++程设实验项目三：黑白棋与基于UCT算法的AI
weixin_34014277的博客
06-20 1701
在这篇博客里，我将总结一下在这次实验中学到的UCT算法实现原理。 首先是参考文章： https://blog.csdn.net/u014397729/article/details/27366363 这是一篇用UCT算法实现四子棋AI的博客。这里给出了UCT的完整伪代码，而且有现成的可运行代码以供参考 https://blog.csdn.net/yw2978777543/article...
棋类博弈-四子棋AI-蒙特卡洛搜索树-UCT-算法设计-适用初学者
05-30
选择阶段从根节点开始，根据一定的策略（如UCT算法）选择最有潜力的子节点进行扩展。扩展是指在选定的子节点下添加新的子节点，代表新的游戏状态。模拟阶段是随机进行多次游戏，直到游戏结束，记录结果。最后，备份...
基于改进UCT算法的国际跳棋博弈系统研究_张家铭1
08-04
【基于改进UCT算法的国际跳棋博弈系统研究】 在国际跳棋博弈系统中，UCT（Upper Confidence bounds applied to Trees）算法是一种广泛应用的决策策略，它结合了探索与利用的平衡，尤其在游戏树搜索中表现出色。UCT...
基于强化学习、蒙特卡洛树搜索的UCT算法智能围棋博弈系统源码(解决围棋死活问题)+项目说明.zip
12-28
基于强化学习、蒙特卡洛树搜索的UCT算法智能围棋博弈系统源码(解决围棋死活问题)+项目说明.zip - Tsumego是在开源项目CleverGo基础上改进的一款专适用于围棋死活问题求解的智能围棋博弈系统，核心是强化学习算法...
引入了UCT算法的围棋AI程序代码
12-27
说是围棋程序，但是直接编译是按五子棋下的。
立体四子棋的深度学习算法实践
02-12
参考资料，https://zhuanlan.zhihu.com/p/32089487，本实现参考借鉴了该资源，本实现的立体四子棋为落子无限制版的立体四子棋(qubic),落子有限制版的立体四子棋必须先下下层的棋子，上层的相关棋子才能继续落子，经过将近4700次的训练，ai水平已经不错了，模型为best_policy.model，python human_play.py即可对战。训练使用python train.py, 如果从0开始训练，请将train.py里的最后部分不加载模型
Source file_围棋算法_
10-01
总之，“Source file_围棋算法_”的实现涵盖了多方面的计算机科学知识，包括搜索算法、博弈论、随机模拟以及优化策略。通过理解并掌握这些算法，开发者不仅可以制作出高质量的棋类游戏，还能在人工智能、机器学习等...
uct的延伸-RAVE
08-08
UCT（Upper Confidence bounds applied to Trees）算法是一种在博弈树中进行搜索的策略，常用于解决如围棋等复杂游戏的决策问题。它通过结合探索与利用的平衡，有效地探索未知的游戏状态。然而，UCT在游戏早期阶段...
基于信心上界蒙特卡洛搜索树（UCT）实现四子棋
毕业作品网站
07-26 1162
每一节点的获胜可能定义为其子节点获胜可能的最大值。若当前局面在搜索树上已被节点 x 表示，且由此局面落子一步产生的所有次局面，均已由 x 的子节点表示，则选择 UCB 信心上界最大的子节点所对应的落子。对于每个节点，统计经该节点及其子节点所表示的局面出发进行的所有博弈，记录博弈的总场数 n 及总获胜场数 m，则对该节点获胜概率的估计为。若当前局面在搜索树上已被节点 x 表示，但由此局面某一落子产生的次局面，并没有由 x 的子节点表示，则选择执行此落子，并在树上扩展出新的节点记录此新局面；
[原创]MC-UCT_一个伟大的自然选择算法(转）
zhp818的专栏
12-17 1313
UCT是怎么走对征子的呢？我想，elife前辈的话一定是对的，否则，MC法不可能有目前的领先地位，一定是有某些地方我们还没有理解到位，出了差错。关于我提出的问题，其实不仅仅是征子的问题，征子只是我用来说明问题的例子，我的问题是：一个导致必胜的着手,一定是在后续的各种任意下法中,胜率最高的着手吗?我还不知道我的思路哪里出了问题，仅仅是相信elife的结论性判断，并不能立即帮助我解决我的算法问题，我还
井字棋UCT
M_harbor的博客
07-10 745
#include "stdafx.h"#include <cstdio>#include <iostream>#include <time.h>#include <cstdlib>#include <math.h>#define SIM_MAX 50#define SIM_MIN 30#define INF 100000#define U...
用python实现UCT算法
05-11
好的，下面是一个简单的Python实现UCT算法的示例代码： ```python import math import random class Node: def __init__(self, state, parent=None): self.state = state self.parent = parent self.children = [] self.wins = 0 self.visits = 0 def is_leaf(self): return len(self.children) == 0 def is_fully_expanded(self): return all(child.visits > 0 for child in self.children) def add_child(self, child_state): child_node = Node(child_state, self) self.children.append(child_node) return child_node class UCT: def __init__(self, state, exploration_constant=1.4): self.root = Node(state) self.exploration_constant = exploration_constant def select(self): node = self.root while not node.is_leaf(): node = self._uct_select(node) return node def expand(self, node): untried_actions = [action for action in self._get_actions(node.state) if not any(child.state == action for child in node.children)] if untried_actions: action = random.choice(untried_actions) child_node = node.add_child(action) return child_node else: return None def simulate(self, state): while not self._is_terminal(state): action = random.choice(self._get_actions(state)) state = self._get_next_state(state, action) return self._get_reward(state) def backpropagate(self, node, reward): while node is not None: node.visits += 1 node.wins += reward node = node.parent def run(self, num_iterations): for i in range(num_iterations): node = self.select() child = self.expand(node) if child: reward = self.simulate(child.state) self.backpropagate(child, reward) else: reward = self.simulate(node.state) self.backpropagate(node, reward) best_child = None best_score = float('-inf') for child in self.root.children: score = child.wins / child.visits + self.exploration_constant * math.sqrt(2 * math.log(self.root.visits) / child.visits) if score > best_score: best_child = child best_score = score return best_child.state def _uct_select(self, node): best_child = None best_score = float('-inf') for child in node.children: score = child.wins / child.visits + self.exploration_constant * math.sqrt(2 * math.log(node.visits) / child.visits) if score > best_score: best_child = child best_score = score return best_child def _get_actions(self, state): # Return a list of possible actions from the given state pass def _get_next_state(self, state, action): # Return the next state given the current state and action pass def _get_reward(self, state): # Return the reward for the given state pass def _is_terminal(self, state): # Return True if the given state is a terminal state, False otherwise pass ``` 要使用这个算法，需要在 `UCT` 类中实现 `_get_actions`、`_get_next_state`、`_get_reward` 和 `_is_terminal` 方法。这些方法需要根据具体的问题实现。 例如，如果我们想使用 UCT 算法解决一个棋盘游戏，可以实现这些方法如下： ```python class Board: def __init__(self): self.board = [[0] * 3 for _ in range(3)] def is_valid_move(self, row, col): return self.board[row][col] == 0 def make_move(self, row, col, player): self.board[row][col] = player def is_win(self, player): for i in range(3): if self.board[i][0] == player and self.board[i][1] == player and self.board[i][2] == player: return True if self.board[0][i] == player and self.board[1][i] == player and self.board[2][i] == player: return True if self.board[0][0] == player and self.board[1][1] == player and self.board[2][2] == player: return True if self.board[0][2] == player and self.board[1][1] == player and self.board[2][0] == player: return True return False def is_full(self): return all(self.board[i][j] != 0 for i in range(3) for j in range(3)) class TicTacToeUCT(UCT): def __init__(self): super().__init__(Board()) def _get_actions(self, state): actions = [] for i in range(3): for j in range(3): if state.is_valid_move(i, j): actions.append((i, j)) return actions def _get_next_state(self, state, action): row, col = action player = 1 if state.is_full() or state.is_win(2) else 2 next_state = Board() next_state.board = [row[:] for row in state.board] next_state.make_move(row, col, player) return next_state def _get_reward(self, state): if state.is_win(1): return 1 elif state.is_win(2): return 0 else: return 0.5 def _is_terminal(self, state): return state.is_full() or state.is_win(1) or state.is_win(2) ``` 这个例子中，我们使用 UCT 算法解决井字棋游戏。对于 `_get_actions` 方法，我们返回一个包含所有空位置的列表。对于 `_get_next_state` 方法，我们先判断当前玩家是谁，然后创建一个新的棋盘状态，并在新状态上执行该动作。对于 `_get_reward` 方法，我们返回 1（玩家1赢）、0（玩家2赢）或0.5（平局）中的一个。对于 `_is_terminal` 方法，我们检查棋盘是否已满或某个玩家已经赢了。 使用这个算法的示例代码如下： ```python game = TicTacToeUCT() for i in range(10000): game.run(1) best_move = game.run(100) print(best_move) ``` 这个例子中，我们在 UCT 算法中运行 10000 次迭代，然后再运行 100 次迭代来选择下一步最佳动作。在这个例子中，UCT 算法将选择最有可能导致胜利的行动。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值