ARTICLE DETAIL

资讯详情

深耕网站建设、视觉设计与SEO优化的一线实战洞察。

Python五子棋人机对战:α-β剪枝与pygame实战调优

Python五子棋人机对战:α-β剪枝与pygame实战调优

简介:围绕α-β剪枝与五子棋人机对战整理的Python实战代码包,适合已掌握Python基础、希望理解博弈树搜索与pygame界面交互的学习者练手。项目将极大极小值搜索与α-β剪枝结合,重点落在电脑走步的候选点位生成、评估函数设计以及搜索效率优化上,同时实现先后手选择、胜负判断、棋盘信息显示和重新开局等完整流程。压缩包共3个文件,以2个py源码和1个txt说明为主,整体约15KB,体量轻便,便于直接阅读、运行与二次修改。已有4707人学习下载。读者可从中获得可运行的人机对战五子棋方案、pygame按钮与棋盘绘制思路、AI落子决策的代码骨架,以及评估函数与剪枝逻辑的对照参考,适合课程设计、算法练习和人工智能入门项目借鉴。

1. 半秒就落子的 AI,为什么反而让人不想跟它下

把 python 五子棋 人机对战 pygame 这套东西跑起来,最先撞见的不是界面问题,而是一个很反直觉的现象:AI 落子不到半秒,你却已经不太想跟它下了。原因不在 pygame 的绘制,也不在鼠标响应,而在 α-β剪枝背后那张评估表——它先把「该堵哪、该冲哪」排了个序,剩下的才是搜索。这份资源给的就是一条完整链路:15 路棋盘的落子与胜负判定、带候选点裁剪的极小极大搜索、棋型打分函数,以及一层薄薄的 pygame 交互壳。它适合两类人:一类是刚学完递归、想找个能跑通的博弈项目练手的;另一类是自己写过五子棋 AI,但总觉得「深度一加就卡死、减了又变傻」的。棋盘状态的表示方式、剪枝真正生效的位置、评估权重的量级关系,才是这份代码里值得逐行拆的部分。

2. 棋盘状态怎么表示:二维数组、四方向扫描和落子的可回滚

棋盘怎么存,决定了后面搜索能不能写得干净。这份代码用的是最朴素的 15×15 二维 list,乍看不如位棋盘(bitboard)精巧,但它换来的是评估函数可以照着「行、列、斜线」的直觉去写,改一个棋型权重不用先翻译成位掩码。本节把状态层拆成四块:存储选型、落子与悔棋、胜负判定、评估需要的行视图。

2.1 为什么没用 bitboard:可读性换掉的那点常数开销

15 路棋盘一共 225 个交叉点,用 Python 的大整数做位棋盘在理论上完全可行,一次落子就是board |= 1 << (r * 15 + c),胜负判定还能用移位与掩码一次性比对整行。真到自己改棋型的时候,问题就来了:你要判断「活三」,得先想清楚这条斜线的掩码该左移几格、两端的空位怎么用~抠出来,调一次权重改一次位运算,血泪经验基本都攒在这。

二维 list 的代价主要落在两处。一是内存访问:grid[r][c]在 CPython 里要走一次 list 索引再走一次,比位运算慢一个量级,但单次也就几十纳秒,一次深度 4 的搜索里总共几万次读取,摊下来是毫秒级。二是拷贝:如果搜索时用「复制棋盘再落子」的写法,每层复制 225 个元素的嵌套 list,节点数一多就是灾难。所以这份代码在搜索里统一用「落子 → 递归 → 撤销」的原地改法,全程只有一块棋盘。

真正要注意的是扩展性。棋盘尺寸写在常量里,改成 19 路时,胜负判定的扫描窗口、评估函数里提取行的循环边界、候选点邻域的范围,三处必须同步改,漏一处就会出现「19 路棋盘上 AI 只在左上角 15 路范围内活动」这种翻车现场。

2.2 落子、悔棋与历史栈

BOARD_SIZE = 15 EMPTY, BLACK, WHITE = 0, 1, 2 class Board: def __init__(self, size=BOARD_SIZE): self.size = size # 0 空 1 黑 2 白,二维 list 便于按行列扫描棋型 self.grid = [[EMPTY] * size for _ in range(size)] # 历史栈:搜索撤销、悔棋、重复局面检测都靠它 self.history = [] def place(self, r, c, player): if not (0 <= r < self.size and 0 <= c < self.size): return False if self.grid[r][c] != EMPTY: return False self.grid[r][c] = player self.history.append((r, c, player)) return True def undo(self): if not self.history: return False r, c, _ = self.history.pop() self.grid[r][c] = EMPTY return True def is_full(self): return len(self.history) == self.size * self.size

place做了两层防御:越界检查和占位检查,返回布尔值而不是抛异常,因为搜索过程中会大量调用它,异常的开销在这个热路径上不划算。undo只弹栈顶,不做其他清理——这一点在接入置换表之后会变成坑,第 5 章会专门说。

参数上有两个可以动的:size换成 19 时,is_full的判断自动跟着变;EMPTY/BLACK/WHITE用 0/1/2 而不是字符串,是为了能用3 - player这个技巧快速取反方,写起来短,跑起来也快。如果非要用枚举,那就得写player.opponent,多一次属性访问,在几万次调用的循环里是实打实的差别。

history存的是三元组而不是只存坐标,因为悔棋时要知道原来落的是谁;如果只存坐标,就得从棋盘上反查,而反查时那颗子已经被清掉了。

2.3 胜负判定:四方向扫描与两个边界

DIRS = ((1, 0), (0, 1), (1, 1), (1, -1)) # 竖、横、主对角、副对角 def is_win(grid, r, c, player, need=5): size = len(grid) for dr, dc in DIRS: count = 1 for sign in (1, -1): nr, nc = r + dr * sign, c + dc * sign while 0 <= nr < size and 0 <= nc < size and grid[nr][nc] == player: count += 1 nr += dr * sign nc += dc * sign if count >= need: # 用 >= 而不是 ==,五子棋里长连也算胜 return True return False

这段代码有两个容易写错的地方,第一处是count的初值。落子之后从当前点出发,当前点本身算一个,所以count = 1,然后向正负两个方向延伸。如果写成 0,四连就会被误判成五连。

第二处是need和>=的关系。标准五子棋里,六连、七连通常也算赢(无禁手规则下),用== 5会让长连漏判;反过来,如果要做带禁手的规则,== 5才对,而且(1, -1)这个负斜方向必须保留,很多手写的判定只写了三个方向,AI 就永远看不到副对角线上的杀棋。

DIRS的定义顺序影响很小,但建议把出现频率高的方向放前面——竖着和横着的连线在实际对局里更常见,短路返回能省一点。

2.4 评估函数的输入:把棋盘切成行视图

棋型识别本质上是字符串匹配,把一行棋转成"0011012000"这样的串,找"011110"(活四)、"01110"(活三)会直观得多。

def iter_lines(grid): """产出棋盘上所有可能成五的线:15 行、15 列、21 条主对角、21 条副对角""" size = len(grid) for r in range(size): yield [grid[r][c] for c in range(size)] for c in range(size): yield [grid[r][c] for r in range(size)] for k in range(-(size - 5), size - 4): # 只保留长度 >= 5 的斜线 line = [grid[r][r - k] for r in range(size) if 0 <= r - k < size] if len(line) >= 5: yield line for k in range(4, 2 * size - 5): line = [grid[r][k - r] for r in range(size) if 0 <= k - r < size] if len(line) >= 5: yield line

对角线起点用k偏移量枚举,-(size-5)到size-5是主对角方向,副对角用k = r + c从 4 枚举到2*size-6。这两个范围如果写错,边角上的棋型就统计不到,表现出来就是「AI 在角落下棋时明显变弱」——这类现象很难直接联想到枚举边界,只能靠固定局面回放去定位。

每调用一次评估就重切一遍所有线,代价是 O(线数 × 线长),15 路棋盘约 70 条线、平均长度 10 出头,一千次左右的基本操作。深度 4、每次十几个候选点,叶子节点上千个,这个开销会占掉一半以上的思考时间。优化方向有两个:一是增量维护,落子时只更新经过该点的 4 条线;二是评估时只扫描候选点周边的局部窗口,不做全盘。前者改动大,后者精度略降,选哪个取决于你对棋力的要求。

3. α-β剪枝到底剪掉了什么:从 negamax 到候选点排序

很多人第一次写剪枝,写完发现「加了 α-β 反而更慢」,多半不是剪枝写错了,而是走法没排序。剪枝能不能生效,取决于好棋是不是先被搜到;顺序不对,α 和 β 永远不收敛,剪枝条件形同虚设。这章把搜索层从递归骨架、候选点生成、评估表、排序技巧四块讲透。

3.1 negamax 骨架与 α≥β 的剪枝条件

极小极大写成两份代码(一份求最大、一份求最小)很啰嗦,用 negamax 把「对手的分数取负」这件事统一掉,代码能短一半。

INF = float("inf") WIN_SCORE = 10_000_000 MAX_DEPTH = 4 def negamax(board, depth, alpha, beta, player): """返回值恒为「站在当前 player 视角」的分数""" moves = gen_moves(board, player) if not moves: return 0, None # 和棋 if depth == 0: return evaluate(board, player), None best_score, best_move = -INF, moves[0] for (r, c) in moves: board.place(r, c, player) if is_win(board.grid, r, c, player): # 越早赢分越高,避免「能赢但拖着」的退化行为 score = WIN_SCORE - (MAX_DEPTH - depth) else: score, _ = negamax(board, depth - 1, -beta, -alpha, 3 - player) score = -score board.undo() if score > best_score: best_score, best_move = score, (r, c) if best_score > alpha: alpha = best_score if alpha >= beta: break # 把这层剩下的走法全剪掉 return best_score, best_move

递归传参时-beta, -alpha的顺序不能反,这是 negamax 的标准写法:子节点用的是「对手视角」的窗口,所以上下界要取反并交换。写反了不会报错,只会让剪枝失效,搜索变慢但结果仍然正确——这类 bug 最难查,因为它不产生错误答案。

WIN_SCORE - (MAX_DEPTH - depth)这一项是「越快赢分越高」。如果直接返回固定的WIN_SCORE,AI 会出现在「三步必胜」和「一步必胜」之间随机选的情况,因为两者分数一样。加上深度修正之后,浅层的胜利分数更高,AI 自然倾向于尽早结束。

alpha >= beta用>=不用>,等号情况下继续搜也只会得到同样或更差的分数,剪掉没有损失。

3.2 候选点生成:不剪邻域,深度 4 都跑不完

225 个空点全展开,每层 225 个分支,深度 4 是 225⁴ ≈ 25 亿个节点。即使有 α-β 平均压到平方根量级,也是几万个节点乘以每节点上千次评估,必然卡死。实际做法是只在已有棋子的邻域内选点。

def gen_moves(board, player, radius=2, limit=12): grid, size = board.grid, board.size cand = set() for r in range(size): for c in range(size): if grid[r][c] == EMPTY: continue for dr in range(-radius, radius + 1): for dc in range(-radius, radius + 1): nr, nc = r + dr, c + dc if (dr or dc) and 0 <= nr < size and 0 <= nc < size \ and grid[nr][nc] == EMPTY: cand.add((nr, nc)) if not cand: # 空盘:直接下天元,别去排序 225 个点 return [(size // 2, size // 2)] scored = [] for (r, c) in cand: # 自己的进攻价值 + 对手在此处的威胁价值(堵点) attack = evaluate_point(grid, r, c, player) defend = evaluate_point(grid, r, c, 3 - player) scored.append((attack + defend * 0.9, (r, c))) scored.sort(key=lambda x: x[0], reverse=True) return [mv for _, mv in scored[:limit]]

radius控制邻域范围,2 表示离已有棋子两格以内的空点才算候选。这个值直接决定分支数:radius=1 时候选点通常 8~20 个,radius=2 是 20~50 个,radius=3 能到 80 以上。实战里 radius=2 配合limit截断已经够用。

limit是硬截断,按分数排序后只保留前 N 个。这个参数是性能和棋力的直接交换:limit=12 时深度 4 大约几百毫秒,limit=20 就奔着一秒以上去。注意limit太小会漏杀——对手的「冲四」如果排在 12 名之外,AI 就看不见,表现成「眼睁睁看着对方连成四子」。

defend * 0.9那个系数是防守权重。取 0.9 意味着「堵对手的收益略低于自己进攻」,AI 会更主动;取 1.1 则偏保守,容易被牵着走。这个数在 0.8~1.2 之间调,超过这个范围棋风会明显变形。

3.3 棋型评估表:五连、活四、冲四、活三的分值梯度

评估函数决定 AI 的「价值观」。这份代码用的是「连子数 + 封堵端数」的二维查表,比逐个匹配字符串快,也够用。

# key = (连续同色子数, 两端被堵的端数) SHAPE_SCORE = { (5, 0): 10_000_000, # 五连,直接赢 (4, 0): 1_000_000, # 活四,两头都能成五,必赢 (4, 1): 100_000, # 冲四,只有一头能成五 (3, 0): 50_000, # 活三,下一手变活四 (3, 1): 5_000, # 眠三 (2, 0): 1_000, # 活二 (2, 1): 100, (1, 0): 10, (1, 1): 1, } def evaluate_point(grid, r, c, player): """假设 player 落在 (r, c),统计四个方向能形成的最大棋型分""" size = len(grid) total = 0 for dr, dc in DIRS: count, blocks = 1, 0 for sign in (1, -1): nr, nc = r + dr * sign, c + dc * sign while 0 <= nr < size and 0 <= nc < size and grid[nr][nc] == player: count += 1 nr += dr * sign nc += dc * sign # 走到的第一个非己方点:出界或对方子都算被堵 if not (0 <= nr < size and 0 <= nc < size) or grid[nr][nc] != EMPTY: blocks += 1 total += SHAPE_SCORE.get((min(count, 5), blocks), 0) return total

分值梯度的关键是量级差,不是具体数字。活四 100 万、冲四 10 万,差 10 倍,意味着「一个活四 > 两个冲四」;活三 5 万,两个活三 10 万,刚好等于一个冲四,这样 AI 会优先做双三而不是单冲四。如果梯度写成 100 万和 90 万,AI 就会分不清轻重,出现「有活四不冲,去堵对方眠三」这种看着很蠢的走法。

min(count, 5)是把六连、七连压回五连档,否则(6, 0)这种 key 在表里查不到,返回 0,长连反而变成最低分。

evaluate的全盘版本就是把所有己方棋子的evaluate_point累加,再减去对手的累加乘以权重:

def evaluate(board, player): mine = sum(evaluate_point(board.grid, r, c, player) for r in range(board.size) for c in range(board.size) if board.grid[r][c] == player) theirs = sum(evaluate_point(board.grid, r, c, 3 - player) for r in range(board.size) for c in range(board.size) if board.grid[r][c] == 3 - player) return mine - int(theirs * 0.95)

这里的 0.95 是全局防守权重。取 1.0 会变成极端保守,AI 全程跟棋;取 0.85 以下则容易忽略对手的杀棋。0.9~0.95 是常见区间,具体看你想让 AI 什么风格。

3.4 走法排序:比加深度更划算的一步

同样的深度,排序好的搜索节点数能差 3~5 倍。上面gen_moves里的排序只是静态的,更进一步的做法是记录历史启发:

class Searcher: def __init__(self): self.history_score = {} # (r, c) -> 累计剪枝收益 self.killer = {} # depth -> 最近一次引发剪枝的走法 def order(self, moves, depth): def key(mv): if mv == self.killer.get(depth): return (2, 0) return (1, self.history_score.get(mv, 0)) return sorted(moves, key=key, reverse=True) def bump(self, mv, depth): self.history_score[mv] = self.history_score.get(mv, 0) + depth * depth self.killer[depth] = mv

bump在每次alpha >= beta触发时调用,把导致剪枝的走法记下来。depth * depth的加权让浅层的剪枝收益更受重视——浅层剪枝省掉的节点更多。

killer move 优先的意义在于:同一个深度上,能引发剪枝的走法往往在兄弟节点里也能引发剪枝,因为局面相似。这个假设在五子棋上成立得不错。

需要提醒的是,这些启发式状态是跨局残留的。换了一盘新棋如果不重置history_score和killer,第一手的排序会带着上一局的记忆,虽然不影响正确性,但会让开局行为不稳定,测试时很难复现。

4. pygame 交互层:坐标换算、事件循环和把搜索挪出主线程

搜索再强,界面卡成 PPT 也没人愿意下。这一层的核心矛盾是:pygame 的事件循环必须跑在主线程,而深度 4 的搜索要几百毫秒,同步调用就会让窗口「未响应」。解决办法不复杂,但几个坐标细节和线程边界容易翻车。

4.1 棋盘绘制与像素坐标换算

import pygame CELL = 40 # 相邻两条线的间距 MARGIN = 40 # 棋盘外边距 STONE_R = 17 # 棋子半径,略小于 CELL/2 才不粘连 def to_pixel(r, c): """棋盘坐标 -> 屏幕像素(线交叉点)""" return MARGIN + c * CELL, MARGIN + r * CELL def to_grid(x, y, size=15, snap=CELL * 0.45): """屏幕像素 -> 棋盘坐标,超出阈值返回 None(点在线中间不落子)""" c = round((x - MARGIN) / CELL) r = round((y - MARGIN) / CELL) if not (0 <= r < size and 0 <= c < size): return None px, py = to_pixel(r, c) if abs(px - x) > snap or abs(py - y) > snap: return None return r, c

snap是吸附阈值,取CELL * 0.45意味着点击位置离交叉点超过 18 像素就不算落子。没有这个判断,玩家点在两个交叉点正中间时会落到最近的那个,体感很怪——尤其手机触屏或高 DPI 屏上。

round而不是int:int(-0.5)得到 0,round(-0.5)也得到 0,但在负偏移时行为不一致,用round更符合「就近取整」的直觉。

绘制顺序建议是:背景 → 网格线 → 星位 → 已落棋子 → 最后一手标记。最后一手加个小圆圈,人机对战时能一眼看清 AI 刚下在哪,这个小细节对体验影响比想象中大。

4.2 主循环与状态机

def main(): pygame.init() screen = pygame.display.set_mode((MARGIN * 2 + CELL * 14, MARGIN * 2 + CELL * 14)) board = Board() human, ai = BLACK, WHITE turn = human ai_thinking = False result = None # None / BLACK / WHITE / "draw" running = True while running: for event in pygame.event.get(): if event.type == pygame.QUIT: running = False elif event.type == pygame.KEYDOWN and event.key == pygame.K_r: board = Board() # 重开:新建对象,别去逐格清空 turn, result, ai_thinking = human, None, False elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 1: if turn != human or ai_thinking or result: continue # 三道闸门,缺一个就出乱子 pos = to_grid(*event.pos) if pos and board.place(*pos, human): if is_win(board.grid, *pos, human): result = human else: turn = ai # ... 绘制 ... pygame.quit()

continue前面那三个条件是本层的核心防护:turn != human挡住 AI 回合的误点,ai_thinking挡住搜索期间的连点,result挡住终局后的继续落子。少任何一个,都会出现「一局下出两颗同色子」或者「赢了还能继续下」的问题。

重开用board = Board()新建对象,而不是遍历清空grid。前者一次性丢弃所有状态(包括历史栈),后者容易漏清history,导致悔棋时撤到上一局的棋。

4.3 搜索放子线程:队列回传与 pygame 的线程边界

pygame 的绘制和事件处理必须在主线程,但纯计算可以扔出去。最简单的做法是起一个线程跑搜索,结果通过queue.Queue回传。

import threading, queue def think_async(board, depth, player, out_q): # 复制一份棋盘快照,避免子线程与主线程同时改同一块内存 snapshot = Board(board.size) snapshot.grid = [row[:] for row in board.grid] snapshot.history = list(board.history) try: score, move = negamax(snapshot, depth, -INF, INF, player) out_q.put(("ok", move, score)) except Exception as e: # 子线程异常不会冒泡到主线程 out_q.put(("err", str(e), None)) # 主循环里 ai_thinking = True q = queue.Queue() threading.Thread(target=think_async, args=(board, MAX_DEPTH, ai, q), daemon=True).start() # 每帧非阻塞地看一眼结果 try: status, move, score = q.get_nowait() if status == "ok" and move: board.place(*move, ai) if is_win(board.grid, *move, ai): result = ai else: turn = human ai_thinking = False except queue.Empty: pass # 还没算完,这一帧继续画「思考中」

三个细节值得说。daemon=True保证窗口关闭时子线程不会拖住进程退出。快照复制是必须的——如果直接传board,主线程的绘制循环和子线程的place/undo会同时改grid,虽然 CPython 有 GIL,但「先读后写」的复合操作不是原子的,偶尔会读到半更新的棋盘,表现成 AI 下在已经有子的位置。

异常捕获也不能省。子线程里抛出的异常默认只打到 stderr,主线程完全不知情,ai_thinking会永远停在 True,玩家点什么都没反应。用队列把错误带回来,至少能打印出来定位。

5. 排查清单:AI 长考、不冲活四、五连不判胜的五个现场

下面这五条是按「调试时最先撞上」的顺序排的,每条都给出可复现的现象,方便对号入座。

5.1 现象:AI 第一步思考几十秒,后面反而快

原因:空盘时gen_moves里没有任何已有棋子,cand为空,如果代码没写「空盘直接返回中心」这个分支,而是退化成遍历全盘 225 个空点并逐个评估,再乘上深度 4 的分支,节点数直接爆炸。更隐蔽的情况是cand为空时返回了全部空点,排序开销本身就吃掉了大部分时间。

解决:在gen_moves开头显式判断if not board.history: return [(size // 2, size // 2)],用历史栈长度判断比遍历棋盘便宜得多。顺便把「AI 第一步」单独加进回归测试,这一步的耗时应该和后续手数在同一量级。

5.2 现象:AI 明明有活四,却跑去堵对方的眠三

原因:SHAPE_SCORE的量级没拉开。活四给 10 万、冲四给 9 万,看上去活四更高,但搜索时对手的眠三在两层之后可能变成活四,累积分数反超。另一种原因是evaluate里只算了己方分数,没减对手分数,AI 完全看不见威胁。

解决:先查梯度,活四和冲四至少差一个数量级;再查evaluate是否做了「己方 − 对手 × 权重」。如果两者都对,就去看gen_moves的limit——活四点如果排在第 13 位被截断,AI 根本搜不到它。调大limit或者临时关掉截断验证一次,能快速定位。

5.3 现象:屏幕上明明五颗子连成一线,游戏却没结束

原因:三种可能。一是is_win用了count == need,长连(六子以上)判不出来;二是DIRS里少了(1, -1),副对角线方向的胜利完全检测不到;三是调用了is_win但传错了player,比如悔棋后仍然拿旧的玩家值去判。

解决:把四个方向都写成单元测试,每个方向各构造一个五连局面,用断言跑一遍。这一步花不了十分钟,但能一次性排掉三个隐患。另外把count >= need改成显式注释,说明这里是「长连也算胜」的规则选择。

5.4 现象:悔棋之后 AI 走了一步莫名其妙的棋

原因:board.undo()只清了grid和history,但搜索器里的history_score、killer,以及可能存在的置换表(按 Zobrist 哈希缓存局面分数)没跟着清。置换表里还留着「这个局面下最佳走法是 X」,而这个局面在悔棋后已经不存在了。

解决:把所有「跨手残留」的状态收进一个Searcher.reset(),悔棋和重开时统一调用。判据很简单:任何不是从board推导出来的缓存,都必须能在一次调用里清空。这也是我自己写搜索时最常忘的一步,后悔药就是提前写个reset并在两个入口都调上。

5.5 现象:连点两下鼠标,棋盘上多出两颗黑子

原因:事件循环里没有ai_thinking锁。玩家落子后turn改成ai,但在 AI 线程返回结果之前,第二次点击仍然满足「轮到我」的条件——因为turn还没来得及被改回去,或者改回去了但 AI 那一手还没落。

解决:加一个显式的ai_thinking布尔量,在提交搜索前置 True,在结果出队后置 False,事件处理里作为第一道闸门。注意不要用turn == ai代替,因为「轮到 AI」和「AI 正在算」是两个不同状态:前者是逻辑归属,后者是执行状态,混用会在 AI 算完之后留一个短暂的窗口期。

6. 把深度 4 的搜索压进半秒:三个旋钮和一套回归自测

调参最怕的是改完觉得「好像变强了」,换个局面又觉得「好像变弱了」。可靠的做法是把三个旋钮固定成一组配置,用同一批局面回放,看耗时和选择两件事。

三个旋钮分别是搜索深度MAX_DEPTH、候选宽度limit、邻域半径radius。它们对耗时的影响不是线性的,粗略关系如下:

旋钮变量起点值调大的后果什么时候该调小
搜索深度MAX_DEPTH4每加 1 层,节点数涨 5~8 倍,棋力提升明显但边际递减界面出现肉眼可见的卡顿
候选宽度limit12更不容易漏杀,但线性拉长每层耗时AI 漏看对手冲四时反而要调大
邻域半径radius2中盘候选点暴涨,远端布局变好开局和中盘前期建议保持 2

我一般按这个顺序试:先把radius定在 2,然后从MAX_DEPTH=2、limit=8开始,每跑一轮记录一次平均耗时,找到「还没卡但已经够用」的那一档,最后再单独加深度验证。经验是深度从 4 到 5 带来的棋力提升,远小于把limit从 12 提到 20 带来的提升,因为后者直接减少了「看不见的杀棋」。

回归自测不用复杂框架,固定几个局面快照就够了:

CASES = [ # (落子序列, 轮到谁, 期望走法, 说明) ([(7, 7), (7, 8), (8, 8), (6, 6)], WHITE, (8, 7), "堵活三"), ([(7, 7), (7, 8), (8, 8), (8, 9), (6, 6)], WHITE, (9, 9), "自己冲四优先"), ([(7, 7)], WHITE, (7, 8), "第二手贴身"), ] def run_cases(): for seq, player, expect, note in CASES: b = Board() for i, (r, c) in enumerate(seq): b.place(r, c, BLACK if i % 2 == 0 else WHITE) import time t0 = time.perf_counter() score, move = negamax(b, MAX_DEPTH, -INF, INF, player) dt = time.perf_counter() - t0 flag = "OK " if move == expect else "MISS" print(f"{flag} {note:12s} 选择={move} 期望={expect} 耗时={dt*1000:.0f}ms")

expect不是「唯一正确答案」,而是「我认为至少该走这里」的下限。改完权重跑一遍,如果原本 OK 的条目变成 MISS,说明这次改动把某个优先级打乱了,回去查SHAPE_SCORE的量级或者defend权重。

耗时那一列要连着看趋势,不要只看绝对值:如果某一档突然从 300ms 跳到 1200ms,多半是候选点在某类局面下暴涨,比如中盘密集区radius=2展开出 60 多个点,limit截断发生在排序之后,排序本身就吃掉了时间。这时候的优化方向是把排序里的evaluate_point换成更便宜的近似值,而不是继续调小limit——后者会直接削弱棋力。

从那以后我每次动评估权重,都强制把这三条用例跑一遍再提交,因为分数梯度这种东西,改一个数字的时候觉得「只是微调」,实际影响的是整棵搜索树的排序,靠肉眼看棋是看不出来的。这套资源里搜索和界面的耦合已经切得比较开,negamax不依赖 pygame,可以脱离窗口单独跑,拿它做参数实验最省事。希望帮到你。

本文还有配套的精品资源,点击获取

返回列表