AlphaZero自博弈算法落地中国象棋：从零训练策略价值网络

简介：面向想在象棋领域复现AlphaZero零方法的强化学习开发者，该代码包完整实现了中国象棋CCZero的训练与对弈流程，包含蒙特卡洛树搜索、深度神经网络、自我对弈及GUI可视化界面，适合具备基础深度学习知识、希望动手实践前沿算法的读者。包内共169个文件，约29.15MB：49个Python脚本承担数据加载、网络训练与推理逻辑，5个JSON保存棋规与训练配置，104个GIF提供界面素材，另有MD说明、PNG图示和可直接加载的h5模型权重，目录结构清晰。已有1850人学习下载，人气可见。通过阅读和运行项目，读者能直观理解AlphaZero在非围棋场景的迁移思路，掌握从棋局生成、并行自弈到模型评估的关键模块实现，并借助带GUI引擎复盘AI走法，是算法学习或二次开发的实用起点。 把 AlphaZero 那套“零人类知识、纯自博弈”的 reinforcement-learning 路线搬到中国象棋上，听起来只是换个棋盘，实际要动的远不止输入尺寸。ChineseChess-AlphaZero 正是把这两件事焊在一起的项目：用 deep-learning 搭策略价值网络，再靠自我对弈不断迭代，整个过程不依赖任何棋谱和人工规则。它解决的核心问题很具体——在没有人类先验的前提下，让一台普通机器从随机走子开始，逐步学会运子、吃子、将军直到赢棋。适合两类人：想亲手实践 AlphaZero 算法但被围棋算力门槛劝退的同学，以及需要一份象棋 AI Demo 做课程设计或项目验证的从业者。象棋盘面小、规则密，反而更适合把整套方法拆开看清。

2. AlphaZero 的核心套路：自博弈、MCTS 与策略价值网络怎么在中国象棋落地

2.1 为什么中国象棋不能直接照搬围棋实现

围棋的原版实现里，输入是 19×19 的落点网格，网络输出 361 个落点概率和 1 个胜率标量。中国象棋是移动型棋类，每一步是“从哪到哪”，棋盘 9×10，可落子位置 90 个，动作组合接近 8010 种候选。直接拿围棋的落子思路处理象棋，第一步就崩了。

动作合法性也是完全不同的约束。围棋只有合法落点和禁入点，象棋每个子按自己的规则走，马蹩马腿、象塞象眼、将帅不能照面、士不能出九宫。这些规则不能指望神经网络去猜，必须在环境层生成合法走法并配合动作掩码。另外终局也是全新概念：被将死、和棋、困毙、长将判负、自然限着。环境要正确返回终局奖励 z，训练才有可用的监督信号。

这个项目最反直觉的一点：网络并不需要“懂规则”，规则由环境层提供；网络只需要从局面和动作分布中拟合出策略与价值。模拟训练时若把规则写错，AI 会在错误的规则里学会“合理”的走法，后期极难纠正。

2.2 自博弈闭环：棋谱从哪来，模型怎么更新

自博弈是 AlphaZero 的引擎。传统强化学习往往依赖外部奖励或人工特征，这套方法是让当前模型分身对弈，用 MCTS 把每个局面的动作概率搜索出来，再与棋局最终胜负一起当作训练标签。

完整流程分三步。

• 自博弈阶段：当前模型自我对弈 N 局，每步用 MCTS 搜索得到动作概率分布 π，并把局面 s 和 π 一起存下来。这一步存的不是棋谱，而是“模型当时认为该往哪走”的软标签。
• 终局回填：棋局结束得到奖励 z，胜 1、负 -1、和 0。把这个 z 回填到此前每一步的标签里，得到 (s_t, π_t, z)。中间的每一步共享同一个最终结果，这就是蒙特卡洛回填。
• 训练更新：策略头拟合 π，用交叉熵；价值头拟合 z，用均方误差；两个 loss 加权相加后反向传播。

迭代方式不是“每下一步棋就训练一次”，而是“跑完一批对局再统一训练若干轮”，然后用新模型重新自博弈。这样数据更稳定，训练吞吐也更高。标签质量会随着模型变强而同步提升：策略被拉向更高质量搜索的结果，价值头越准搜索就越准，形成正循环。

2.3 网络结构怎么选：从 19×19 改成 9×10 不只是改输入维度

原版网络是残差卷积塔加策略头和价值头，输入 49 个通道，20 个残差块，256 个卷积核。复现时若照搬这套配置，训练成本太高，象棋场景普遍把规模缩到 6～10 个残差块、128～256 个 filter。

常见的网络骨架是：

• 共享层：3×3 卷积 + BatchNorm + ReLU，后面接若干残差块，提取局面特征；
• 策略头：两层卷积加全连接，输出动作空间维度的 logits；
• 价值头：两层卷积加全连接，最后压缩到 (-1, 1) 的标量；
• 损失函数：L = -πᵀ log p + (v - z)² + c·‖θ‖²。

我在复现时踩过的坑是：残差块堆到 20 层，棋力并没有肉眼可见的上涨，训练时间却翻了四倍。象棋盘面信息密度比围棋低，参数规模不是越大越好，关键是让策略头和价值头共享同一套特征提取层，避免各自为政。输入里加一个“当前轮到谁走”的平面也很有用，能帮网络区分颜色信息，防止价值判断出现对称性误判。

3. 代码拆解：MCTS、策略价值网络与训练循环，参数到底怎么设

3.1 项目模块与改动主线

从这类项目的源码包看，模块划分一般遵循同一个套路。先搞清楚每个模块的职责，再动手改，就不会对着代码发呆。

代码风格上，这个项目沿用了一套贴近教学的 DeeplearningPython 式写法：模块边界清楚、每个文件只干一件事。新手不用一上来读全部代码，先定位 environment 和 train 两个模块，把输入输出跑通，再去看 MCTS 的搜索细节。

3.2 MCTS 搜索：UCT 公式、模拟次数与探索常数 c_puct

MCTS 是整个系统的核心。下面是一段简化的 TreeNode 实现，保留了搜索的主干逻辑。

import numpy as np class TreeNode: def __init__(self, parent=None, prior=0.0): self.parent = parent self.children = {} self.visit_count = 0 self.total_value = 0.0 self.prior = prior @property def q_value(self): return self.total_value / self.visit_count if self.visit_count else 0.0 def expand(self, action_probs): for action, prob in action_probs: if action not in self.children: self.children[action] = TreeNode(parent=self, prior=prob) def select(self, c_puct): best_action, best_score = None, -float("inf") for action, child in self.children.items(): score = child.q_value + c_puct * child.prior * np.sqrt(self.visit_count) / (1 + child.visit_count) if score > best_score: best_action, best_score = action, score return best_action, self.children[best_action] def update(self, leaf_value): self.visit_count += 1 self.total_value += leaf_value if self.parent: self.parent.update(-leaf_value)

这段代码的核心在 select 的分数公式：child.q_value 是当前节点的平均价值，child.prior 是策略头给出的先验概率，c_puct 控制探索强度，sqrt(父节点访问数) / (1 + 子节点访问数) 让探索随访问次数自然衰减。update 里向上层传值时取负，是因为对手视角的价值要翻转。

参数方面，我一般把 c_puct 初始化在 2.5～5 之间，然后观察棋力曲线微调。模拟次数对自博弈数据质量影响很大：每步只有 20～50 次模拟时，MCTS 返回的 π 分布噪声大，模型学到的是“乱试”策略；提升到 200～400 次后，分布才稳定到接近当前模型真实水平。象棋不比围棋，400 次模拟在普通桌面 CPU 上已经能跑出可用效果，没必要一上来就冲到 1600。

3.3 单次迭代训练：自博弈采样、批大小与学习率调度

训练循环的组织方式，直接决定你等一周后看到的是棋力增长还是 loss 横跳。下面是一个标准的单迭代流程。

for it in range(total_iterations): samples = [] for game_id in range(num_games): board = new_game() while not board.is_terminal(): mcts = MCTS(model, simulations=400) action = mcts.search(board) board.apply(action) samples.append((board.snapshot(), mcts.action_probs(), None)) z = board.result() # 1 / -1 / 0 for i in range(len(samples)): s, pi, _ = samples[i] samples[i] = (s, pi, z) train_one_epoch(samples, model, optimizer) if it % 10 == 0: evaluate_and_save(model, it)

终局 z 回填没有额外逻辑，就是把同一个 z 赋给本局所有中间局面。这让价值头学到的是“从这个局面出发最终的结果”，而不是“当前子力优劣”。训练时 batch size 取 256 或 512，学习率用 0.02、动量 0.9，跑若干轮后做阶梯式衰减。

有一个容易被忽略的点：自博弈 prob 分布是 MCTS 按访问计数归一化得到的，不是策略头直接输出的 logits。直接拿 logits 当标签会丢失搜索带来的信息增益，模型会退化成纯网络前传的胜负预测器。

4. 中国象棋怎么喂给神经网络：状态编码、动作映射与棋规适配

4.1 局面编码：15 个平面通道怎么搭

大多数复现版本采用 15 通道的编码方案，把当前局面变成一个 (15, 9, 10) 的张量。

import numpy as np def encode_state(board, current_player): planes = np.zeros((15, 9, 10), dtype=np.float32) for row in range(10): for col in range(9): piece = board[row][col] if piece: ch = piece.char idx = piece_index(ch) # 0 到 6 offset = 0 if piece.color == current_player else 7 planes[offset + idx][row][col] = 1.0 return planes

当前方和对方分开编码，是为了让网络在卷积时天然区分敌我子力。被将军这个通道很关键：它告诉价值头“现在处于被将军状态”，MCTS 搜索也能据此优先处理应将走法。

4.2 动作空间：吃子、走子、特殊着法如何映射成固定维度

神经网络输出必须是固定维度，所以动作不能按变长的方式逐子枚举。常见做法是使用 90×89 = 8010 个动作槽：90 个出发位置，每个出发位置排除自身后留 89 个终点候选。非法走法通过动作掩码屏蔽。

NUM_ACTIONS = 90 * 89 def encode_legal_mask(board, player): mask = np.zeros(NUM_ACTIONS, dtype=np.float32) for piece in board.pieces_of(player): from_idx = piece.row * 9 + piece.col for to_row, to_col in board.legal_to(piece): to_idx = to_row * 9 + to_col shifted = to_idx if to_idx < from_idx else to_idx - 1 action_id = from_idx * 89 + shifted mask[action_id] = 1.0 return mask

动作与策略头的 logits 做点乘时，非法槽位全部置零，softmax 后的概率只落在合法走法上。这种设计比按棋子类型划分更省事，也更容易跨规则复用。细心的朋友会发现 8010 槽位里有大量空位，这是为了换取结构简单，训练时并不需要额外处理，MCTS 扩展时只扩展 mask 里为 1 的节点即可。

4.3 棋规与胜负：长将、困毙、自然限着，谁说了算

中国象棋的棋规比围棋复杂，主要体现在“被将军”和“判和”两条。环境层必须把规则写对，否则后面全是白练。

• 被将军后的走法过滤：走完一步后，如果己方帅/将仍在对方火力范围内，这步就是非法走法。最稳妥的写法是“伪合法走法 + 走完回查”，而不是手写一堆例外。
• 困毙判负：一方无子可动直接输，不是和棋。很多实现会把“无合法走法”默认判和，这是典型的隐蔽 bug。
• 重复局面：三次重复可以判和，或者通过“不吃子超过 60 回合判和”来强制终止。否则 MCTS 会在长将循环里无限搜索。
• 终局奖励：胜 1、负 -1、和 0，三者必须清晰区分，不能把负和混在一起。

def legal_moves(board, player): moves = [] for piece in board.pieces(player): for to in board.pseudo_legal_moves(piece): board.make_move(piece, to) if not is_in_check(board, player): moves.append((piece, to)) board.undo_move() return moves def is_in_check(board, player): king_pos = board.find_king(player) for opponent in board.pieces(opponent_of(player)): if king_pos in board.attacked_squares(opponent): return True return False

“先走再检查是否被将军”这个思路，比逐个棋子枚举攻击线要简洁得多，也几乎不会漏掉马后炮、蹩马腿这类组合攻击。代价是多走一步再撤销，性能上多一层开销，但正确性优先。

5. 训练避坑指南：模型乱走、棋力倒退、显存爆炸的五种典型翻车现场

5.1 现象：训练跑了两三天，棋力还是乱走

loss 在降，但模型经常白送车马炮，一局对弈看起来毫无章法。这种翻车最常见的原因是自博弈数据质量太差：每步模拟次数只有 20～50，MCTS 返回的 π 分布接近随机，策略头拟合的全是噪声。

解决方法是先把模拟次数提到 200 以上，再检查回填的 z 有没有正确赋值。可以在代码里加一行统计，快速定位问题。

from collections import Counter print(Counter(z for _, _, z in samples))

如果 z 几乎全是 0，多半是判和逻辑写得过宽，把将死局面也判成了和棋。如果 1 和 -1 都有但棋力依旧乱走，优先怀疑模拟次数过低，其次看学习率是否过大导致策略震荡。

5.2 现象：模拟次数加大后棋力反而倒退

把模拟次数从 200 提到 1000，新旧模型自对战胜率反而掉了几个点。这不是玄学，而是训练步数与数据分布没跟上。MCTS 搜索变准后，自博弈产生的数据分布更锐利，但训练步数还是原来的量，模型来不及拟合新分布就进入了下一轮迭代。

我自己跑这类实验时，会先把模拟次数固定在某个值，跑完一个完整评估周期确认棋力增长后再上调，而不是边改参数边长跑。新旧模型对比评估也要固定评估条件，保证对比是在同一搜索次数下做的。

5.3 现象：自博弈数据里几乎全是和棋

当判和条件太宽松时，两个水平接近的模型很容易走成互相纠缠的重复局面，最后被自然限着判和。价值头拟合大量 0 分样本，会逐渐退化成一个输出接近 0 的常数网络。

我的经验做法是把不吃子判和的回合数从 60 提到 100，同时在回填 z 时给和棋加一个微小扰动：先手 +0.1，后手 -0.1。这个扰动不会改变策略学习的正确性，但能让价值头在和棋主导的数据里保持梯度。如果你不想引入这种人为偏置，至少保证判和条件不会把胜负局面误吞。

5.4 现象：显存/内存吃满，训练直接崩

常见原因有三个：样本缓冲无限累积，旧样本占据大量内存；模型规模设得太大；自博弈和训练同时挤在同一张显卡上。前两个最好解。

MAX_BUFFER = 1000 if len(sample_buffer) > MAX_BUFFER: sample_buffer = sample_buffer[-MAX_BUFFER:]

给缓冲加一个上限，只保留最新样本，旧样本直接丢弃。模型层面，先跑 6 个残差块、128 个 filter 的配置，确认收敛后再逐步加层。自博弈进程如果和训练共享 GPU，建议把 MCTS 放在 CPU 上跑，GPU 只做批量推理，能显著减少显存竞争。

5.5 现象：MCTS 卡在长将循环里出不来

搜索树访问次数持续增长，但程序就是不停在对某个重复局面反复展开。原因是环境层没有对重复局面做判和，长将成了合法动作，树里出现了环。

解决思路是在 MCTS 遇到重复局面时直接按和棋处理，不再展开子节点。

if board.is_threefold_repetition(): return 0.0 # 重复局面直接返回和棋分数，不继续展开

同时在自博弈环境里对“长将”类走法做限制，连续将军超过一定次数判负。这样搜索树不会陷入环，训练数据也不会被无意义的长将节奏污染。

6. 用对弈实验验证棋力，再把模型用起来

6.1 自博弈评估前先做新旧模型 PK

训练过程里最容易被骗的是 loss：loss 下降不代表棋力上涨，也可能只是策略头拟合了更多噪声。可靠的验证方式是新旧模型交替先后手打一组短对局。

def arena(model_a, model_b, num_games=20, simulations=400): wins = {"a": 0, "b": 0, "draw": 0} for i in range(num_games): result = run_one_game( model_a if i % 2 == 0 else model_b, model_b if i % 2 == 0 else model_a, simulations, ) if result == 1: wins["a" if i % 2 == 0 else "b"] += 1 elif result == -1: wins["b" if i % 2 == 0 else "a"] += 1 else: wins["draw"] += 1 return wins

交替先后手是为了抹平红黑先手优势。20 局样本不大，但足够看出明显趋势：新模型胜率如果能稳定超过 55%，就说明更新方向是对的。

6.2 用贪吃基线做参考系

光看新旧模型互殴还不够，因为两个模型可能一起退步。我会额外准备一个只会“贪吃子”的基线脚本，它不搜索，只选能吃最大子力的动作。训练好的模型如果连这个基线都压不住，说明基本棋理还没学会。等模型对基线胜率稳定超过 90%，再放开长跑和调参，不至于在错误方向上浪费 GPU。

6.3 部署时把搜索次数降下来

训练时模拟次数设高是为了制造高质量标签，部署时则要权衡时延。常见做法是把线上搜索次数压到 50～100，配合训练时保留的残差块规模，每步耗时能控制在可接受范围。也可以加一道快速剪枝：先用价值头对候选动作粗筛，把明显送吃的槽位直接屏蔽，再进入正式搜索，用少量模拟次数达到接近完整搜索的棋力。

这个项目的价值在于把 AlphaZero 的完整链路压缩到了一个适合个人复现的规模里。从那以后，我每次跑自博弈训练都会先强制打一轮 20 局短评估，确认新模型对旧版本有稳定优势再放开长跑；当时跳过判和规则检查，让模型在错误的规则里白跑了好几天，也成了我改环境的默认动作。希望帮到你。

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