基于深度强化学习的五子棋博弈系统：从零搭建指南与避坑实践

1次阅读

没有评论

共计 4078 个字符，预计需要花费 11 分钟才能阅读完成。

五子棋作为一种经典的策略游戏，传统上常使用 Minimax 算法结合 Alpha-Beta 剪枝来实现 AI 对战。然而这种方法存在几个明显缺陷：

计算复杂度高 ：随着搜索深度的增加，计算量呈指数级增长
依赖人工评估函数 ：需要精心设计棋盘状态的评估规则，难以覆盖所有可能局面
缺乏自适应能力 ：无法从对局中学习改进策略

深度强化学习通过神经网络直接学习从状态到动作的映射，特别适合五子棋这类策略游戏：

端到端学习 ：无需人工设计评估函数
持续进化 ：通过自我对弈不断提升策略
泛化能力 ：神经网络可以泛化到未见过的棋局状态

常见 DRL 算法在棋类游戏中的表现差异显著：

DQN：适合离散动作空间，但难以处理长序列决策
Policy Gradient：直接优化策略，但训练不稳定
AlphaZero：结合蒙特卡洛树搜索 (MCTS)，但实现复杂

Proximal Policy Optimization (PPO) 因其以下特点成为我们的首选：

策略更新的信任区域机制保证训练稳定性
支持连续和离散动作空间
相比 TRPO 实现更简单
在 OpenAI 的基准测试中表现优异

采用 14×14×3 的张量表示棋盘（标准 15×15 棋盘去除边缘）：

import torch
import numpy as np

class BoardEncoder:
    def __init__(self, size=14):
        self.size = size

    def encode(self, board):
        """
        输入: 二维 numpy 数组表示的棋盘
        输出: (3,14,14) 的 PyTorch 张量
        """
        tensor = torch.zeros((3, self.size, self.size))
        # 通道 0: 当前玩家棋子位置
        tensor[0] = torch.from_numpy((board == 1).astype(np.float32))
        # 通道 1: 对手棋子位置
        tensor[1] = torch.from_numpy((board == 2).astype(np.float32))
        # 通道 2: 当前玩家颜色 (全 0 表示黑棋，全 1 表示白棋)
        tensor[2] = torch.full((self.size, self.size), float(board.current_player))
        return tensor

采用经典的 Actor-Critic 结构：

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

class PolicyNetwork(nn.Module):
    def __init__(self, input_shape, action_dim):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)

        # 策略头
        self.policy_conv = nn.Conv2d(128, 4, kernel_size=1)
        self.policy_fc = nn.Linear(4*14*14, action_dim)

        # 价值头
        self.value_conv = nn.Conv2d(128, 2, kernel_size=1)
        self.value_fc1 = nn.Linear(2*14*14, 64)
        self.value_fc2 = nn.Linear(64, 1)

    def forward(self, x):
        # 共享特征提取
        x = F.relu(self.conv1(x))
        x = F.relu(self.conv2(x))
        x = F.relu(self.conv3(x))

        # 策略头
        policy = F.relu(self.policy_conv(x))
        policy = policy.view(-1, 4*14*14)
        policy = F.softmax(self.policy_fc(policy), dim=-1)

        # 价值头
        value = F.relu(self.value_conv(x))
        value = value.view(-1, 2*14*14)
        value = F.relu(self.value_fc1(value))
        value = torch.tanh(self.value_fc2(value))

        return policy, value

五子棋的 reward 设计需要平衡短期和长期收益：

即时奖励 ：
获胜：+1
失败：-1
平局：0
无效落子：-0.1（防止重复无效尝试）
中间奖励 ：
形成活四：+0.5
形成冲四：+0.3
形成活三：+0.1

# 超参数配置
config = {
    'lr': 3e-4,            # 学习率
    'gamma': 0.99,         # 折扣因子
    'clip_epsilon': 0.2,   # PPO 剪切参数
    'entropy_coef': 0.01,  # 熵正则化系数
    'batch_size': 256,     # 批量大小
    'epochs': 10,          # 每次采样的训练轮数
    'max_steps': 1e6,      # 最大训练步数
}

def train_ppo(env, policy, optimizer, config):
    """PPO 训练主循环"""
    state = env.reset()
    episode_rewards = []

    for step in range(config['max_steps']):
        # 收集经验
        states, actions, rewards, dones = [], [], [], []

        for _ in range(config['batch_size']):
            # 选择动作
            state_tensor = encoder.encode(state)
            with torch.no_grad():
                action_probs, _ = policy(state_tensor.unsqueeze(0))
            action = torch.multinomial(action_probs, 1).item()

            # 执行动作
            next_state, reward, done, _ = env.step(action)

            # 存储转移
            states.append(state)
            actions.append(action)
            rewards.append(reward)
            dones.append(done)

            state = next_state if not done else env.reset()

            if done:
                episode_rewards.append(sum(rewards))
                rewards = []

        # 计算优势
        states_tensor = torch.stack([encoder.encode(s) for s in states])
        _, values = policy(states_tensor)
        values = values.squeeze()

        # PPO 更新
        for _ in range(config['epochs']):
            # 计算新旧策略概率比
            new_probs, new_values = policy(states_tensor)
            new_probs = new_probs.gather(1, torch.tensor(actions).unsqueeze(1))

            # 计算策略梯度损失
            ratios = new_probs / old_probs
            surr1 = ratios * advantages
            surr2 = torch.clamp(ratios, 1-config['clip_epsilon'], 
                               1+config['clip_epsilon']) * advantages
            policy_loss = -torch.min(surr1, surr2).mean()

            # 价值函数损失
            value_loss = F.mse_loss(new_values.squeeze(), returns)

            # 熵正则化
            entropy = -(new_probs * torch.log(new_probs + 1e-10)).mean()

            # 总损失
            loss = policy_loss + 0.5*value_loss - config['entropy_coef']*entropy

            # 反向传播
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

通过大量实验总结的黄金参数组合：