深度学习高级教程：基于生成对抗网络的五子棋对战AI
·
深度学习高级教程：基于生成对抗网络的五子棋对战AI
1. 引言
1.1 什么是生成对抗网络？
生活场景类比：生成对抗网络（GAN）就像一对对手，一个是画家（生成器），一个是艺术评论家（判别器）。画家试图创作以假乱真的画作，评论家则试图区分真假画作。两者在不断的对抗中共同进步，最终画家能创作出几乎以假乱真的作品。
生成对抗网络是一种深度学习模型，它由两个神经网络相互竞争、共同进化：
- 生成器：生成数据样本，试图欺骗判别器
- 判别器：区分真实数据和生成器生成的假数据
1.2 为什么要学习生成对抗网络？
生成对抗网络在很多领域都取得了突破性的进展：
- 图像生成：生成逼真的图像、艺术作品
- 视频生成：生成流畅的视频片段
- 自然语言处理：生成文本、对话
- 游戏AI：训练智能游戏对手
- 数据增强：生成用于训练的合成数据
学习生成对抗网络可以让你掌握这些前沿技术，为从事人工智能相关工作打下坚实的基础。
1.3 本教程的目标
在本教程中，我们将：
- 学习生成对抗网络的基本原理
- 理解残差块和注意力机制的工作原理
- 用PyTorch实现一个基于GAN的五子棋对战AI
- 训练和测试模型，分析结果
- 实现AI的自我对弈和进化
2. 环境搭建
2.1 WSL Ubuntu安装
首先，我们需要在Windows上安装WSL（Windows Subsystem for Linux）。请按照微软官方文档的步骤进行安装：安装WSL
2.2 GPU驱动安装
要使用GPU加速深度学习，我们需要安装NVIDIA GPU驱动。请从NVIDIA官网下载并安装适合你GPU型号的驱动：NVIDIA驱动下载
2.3 安装Python环境
-
升级系统环境
sudo apt update && sudo apt -y dist-upgrade -
安装Python 3.12
sudo apt -y install --upgrade python3 python3-pip python3.12-venv -
设置国内镜像源（加速下载）
pip3 config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
2.4 创建虚拟环境
虚拟环境可以隔离不同项目的依赖，避免版本冲突。
-
创建项目目录
mkdir pytorch-code && cd pytorch-code -
创建并激活虚拟环境
python3 -m venv .venv && source .venv/bin/activate -
升级基础依赖
python -m pip install --upgrade pip setuptools wheel -i https://pypi.tuna.tsinghua.edu.cn/simple
2.5 安装PyTorch
PyTorch是一个流行的深度学习框架，它提供了丰富的工具和API，方便我们构建和训练深度学习模型。
# 安装PyTorch GPU版本
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu128
# 安装其他依赖
pip install matplotlib numpy seaborn scikit-learn
2.6 验证安装
安装完成后，我们可以运行以下命令来验证PyTorch和CUDA是否正确安装：
import torch
print(f"PyTorch版本: {torch.__version__}")
print(f"CUDA是否可用: {torch.cuda.is_available()}")
if torch.cuda.is_available():
print(f"GPU型号: {torch.cuda.get_device_name(0)}")
print(f"CUDA版本: {torch.version.cuda}")
如果输出显示CUDA可用，并且显示了你的GPU型号，说明安装成功！
3. 生成对抗网络原理大白话
3.1 什么是生成对抗网络？
生活场景类比：生成对抗网络就像一个造假者和一个鉴宝师在互相竞争。造假者（生成器）试图制造假文物，鉴宝师（判别器）试图区分真假文物。随着时间的推移，造假者的技艺越来越高超，鉴宝师的眼光也越来越敏锐，最终造假者能制造出几乎以假乱真的文物。
在深度学习中，生成对抗网络由两个神经网络组成：
- 生成器（Generator）：生成假数据，试图欺骗判别器
- 判别器（Discriminator）：区分真实数据和生成器生成的假数据
3.2 GAN的基本结构
生活场景类比：GAN就像一个模拟对抗的游戏，生成器和判别器在不断的对抗中共同进步。
graph TD
A[真实数据<br>15×15五子棋棋盘] --> B[判别器<br>CNN]
C[生成器<br>CNN] --> D[生成的落子位置<br>15×15概率图]
D --> B
B --> |损失反馈| E[训练<br>优化器]
E --> |更新参数| B
E --> |更新参数| C
3.3 残差块和注意力机制
生活场景类比：残差块就像在建筑中使用的钢筋混凝土结构，它可以增强结构的稳定性和承载能力。注意力机制就像你在阅读时会重点关注文章的关键部分，而不是平均分配注意力。
- 残差块：解决深层网络的梯度消失问题，允许信息直接从低层传递到高层
- 注意力机制：让模型能够自动关注重要的特征，提高模型的表现能力
4. 生成对抗网络原理详解
4.1 生成器
生成器负责生成最佳落子位置，它接收当前棋盘状态作为输入，输出一个15×15的概率图，表示每个位置的落子价值。生成器使用了残差块和通道注意力机制，能够捕捉棋盘的复杂特征和长期依赖关系。
4.2 判别器
判别器负责评估落子位置的优劣，它接收当前棋盘状态和落子位置作为输入，输出一个概率值，表示这个落子位置是真实（好）还是假（坏）的。判别器使用了卷积神经网络，能够学习到棋盘的模式和策略。
4.3 训练过程
GAN的训练是一个极小极大博弈过程：
- 固定生成器，训练判别器：让判别器能够更好地区分真实落子和生成的落子
- 固定判别器，训练生成器：让生成器能够生成更好的落子，欺骗判别器
- 重复上述过程，直到收敛
4.4 损失函数
生成对抗网络使用两个损失函数：
- 判别器损失：衡量判别器区分真假落子的能力
- 生成器损失：衡量生成器生成的落子能够欺骗判别器的程度
5. 代码实现与解读
5.1 项目结构
我们的项目按照以下结构组织：
module7/
├── model.py # GAN模型定义（生成器和判别器）
├── game.py # 五子棋游戏逻辑
├── utils.py # 工具函数
├── train.py # 模型训练
├── test.py # 模型测试
├── models/ # 模型保存目录
└── results/ # 结果可视化目录
代码架构图
代码流程图
flowchart TD
A[开始] --> B[初始化游戏<br>game.py]
B --> C[初始化模型<br>model.py]
C --> D[训练模型<br>train.py]
D --> E[保存模型<br>models/]
D --> F[绘制训练曲线<br>results/]
E --> G[测试模型<br>test.py]
F --> G
G --> H[生成对战结果<br>results/]
H --> I[结束]
5.2 游戏逻辑实现（game.py）
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
五子棋游戏逻辑实现
开发思路：
1. 设计一个清晰的棋盘状态表示方法
2. 实现落子、胜负判断等核心游戏逻辑
3. 提供可视化功能，便于调试和观察
4. 支持获取合法走法和棋盘状态
开发过程：
- 首先定义棋盘大小和游戏规则
- 实现落子函数，处理边界条件
- 实现胜负判断，检查所有可能的获胜组合
- 添加棋盘可视化功能
- 实现获取合法走法的功能
"""
import numpy as np
import matplotlib.pyplot as plt
class GobangGame:
"""
五子棋游戏类，实现游戏逻辑和状态管理
"""
def __init__(self):
"""初始化游戏
棋盘大小为15×15，使用15×15×2的张量表示棋盘状态
- 通道0：黑方棋子位置
- 通道1：白方棋子位置
"""
# 棋盘大小
self.board_size = 15
# 初始化棋盘状态：15×15×2，全0表示空棋盘
self.board = np.zeros((self.board_size, self.board_size, 2), dtype=np.float32)
# 当前玩家：0表示黑方，1表示白方
self.current_player = 0
# 游戏结束标记
self.game_over = False
# 获胜玩家：0表示黑方获胜，1表示白方获胜，-1表示平局
self.winner = -1
# 步数计数
self.step_count = 0
def reset(self):
"""重置游戏状态
将棋盘清空，重置当前玩家和游戏结束标记
"""
self.board = np.zeros((self.board_size, self.board_size, 2), dtype=np.float32)
self.current_player = 0
self.game_over = False
self.winner = -1
self.step_count = 0
def is_valid_move(self, row, col):
"""检查落子是否合法
参数：
row: 行索引
col: 列索引
返回：
bool: 落子是否合法
"""
# 检查坐标是否在棋盘范围内
if row < 0 or row >= self.board_size or col < 0 or col >= self.board_size:
return False
# 检查该位置是否为空（两个通道都为0）
if np.sum(self.board[row, col]) > 0:
return False
# 检查游戏是否已结束
if self.game_over:
return False
return True
def make_move(self, row, col):
"""执行落子
参数：
row: 行索引
col: 列索引
返回：
bool: 落子是否成功
"""
# 检查落子是否合法
if not self.is_valid_move(row, col):
return False
# 在当前玩家的通道上落子
self.board[row, col, self.current_player] = 1
# 检查是否获胜
if self.check_winner(row, col):
self.game_over = True
self.winner = self.current_player
# 检查是否平局（棋盘已满）
elif self.step_count >= self.board_size * self.board_size - 1:
self.game_over = True
self.winner = -1
# 切换玩家
self.current_player = 1 - self.current_player
# 步数加1
self.step_count += 1
return True
def check_winner(self, row, col):
"""检查是否有玩家获胜
参数：
row: 最后落子的行索引
col: 最后落子的列索引
返回：
bool: 是否有玩家获胜
"""
# 获取当前玩家的棋子颜色
player = 1 - self.current_player # 因为刚刚切换了玩家，所以需要取反
# 检查水平方向
count = 1
# 向左检查
c = col - 1
while c >= 0 and self.board[row, c, player] == 1:
count += 1
c -= 1
# 向右检查
c = col + 1
while c < self.board_size and self.board[row, c, player] == 1:
count += 1
c += 1
if count >= 5:
return True
# 检查垂直方向
count = 1
# 向上检查
r = row - 1
while r >= 0 and self.board[r, col, player] == 1:
count += 1
r -= 1
# 向下检查
r = row + 1
while r < self.board_size and self.board[r, col, player] == 1:
count += 1
r += 1
if count >= 5:
return True
# 检查对角线方向（左上到右下）
count = 1
# 左上方向
r, c = row - 1, col - 1
while r >= 0 and c >= 0 and self.board[r, c, player] == 1:
count += 1
r -= 1
c -= 1
# 右下方向
r, c = row + 1, col + 1
while r < self.board_size and c < self.board_size and self.board[r, c, player] == 1:
count += 1
r += 1
c += 1
if count >= 5:
return True
# 检查对角线方向（右上到左下）
count = 1
# 右上方向
r, c = row - 1, col + 1
while r >= 0 and c < self.board_size and self.board[r, c, player] == 1:
count += 1
r -= 1
c += 1
# 左下方向
r, c = row + 1, col - 1
while r < self.board_size and c >= 0 and self.board[r, c, player] == 1:
count += 1
r += 1
c -= 1
if count >= 5:
return True
return False
def get_valid_moves(self):
"""获取所有合法走法
返回：
list: 合法走法列表，每个元素是(row, col)元组
"""
valid_moves = []
for row in range(self.board_size):
for col in range(self.board_size):
if self.is_valid_move(row, col):
valid_moves.append((row, col))
return valid_moves
def get_board_state(self):
"""获取当前棋盘状态
返回：
tuple: (board, current_player, game_over, winner)
"""
return self.board.copy(), self.current_player, self.game_over, self.winner
def visualize_board(self):
"""可视化棋盘
使用matplotlib绘制棋盘和棋子
"""
fig, ax = plt.subplots(figsize=(10, 10))
# 绘制网格线
for i in range(self.board_size + 1):
ax.axhline(i - 0.5, color='black', linewidth=0.5)
ax.axvline(i - 0.5, color='black', linewidth=0.5)
# 绘制棋子
for row in range(self.board_size):
for col in range(self.board_size):
# 黑方棋子（通道0）
if self.board[row, col, 0] == 1:
ax.scatter(col, row, s=200, color='black', marker='o')
# 白方棋子（通道1）
elif self.board[row, col, 1] == 1:
ax.scatter(col, row, s=200, color='white', edgecolor='black', marker='o')
# 设置坐标轴
ax.set_xlim(-0.5, self.board_size - 0.5)
ax.set_ylim(-0.5, self.board_size - 0.5)
ax.set_xticks(range(self.board_size))
ax.set_yticks(range(self.board_size))
ax.set_title(f"Gobang Game - Current Player: {'Black' if self.current_player == 0 else 'White'}")
ax.invert_yaxis() # 使(0,0)位于左上角
plt.grid(False)
plt.show()
# 测试代码
if __name__ == "__main__":
# 创建游戏实例
game = GobangGame()
# 测试落子
game.make_move(7, 7) # 黑方在中心点落子
game.make_move(7, 8) # 白方在右侧落子
game.make_move(8, 7) # 黑方在下方落子
game.make_move(8, 8) # 白方在右下角落子
# 可视化棋盘
game.visualize_board()
print(f"当前玩家: {'黑方' if game.current_player == 0 else '白方'}")
print(f"游戏结束: {game.game_over}")
print(f"获胜玩家: {game.winner}")
5.3 模型定义（model.py）
import torch
import torch.nn as nn
class ResidualBlock(nn.Module):
"""残差块，有助于梯度流动和信息保留"""
def __init__(self, in_channels, out_channels, stride=1):
super(ResidualBlock, self).__init__()
self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)
self.bn1 = nn.BatchNorm2d(out_channels)
self.relu = nn.ReLU(inplace=True)
self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)
self.bn2 = nn.BatchNorm2d(out_channels)
# 快捷连接，处理通道数变化
self.shortcut = nn.Sequential()
if stride != 1 or in_channels != out_channels:
self.shortcut = nn.Sequential(
nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),
nn.BatchNorm2d(out_channels)
)
def forward(self, x):
out = self.conv1(x)
out = self.bn1(out)
out = self.relu(out)
out = self.conv2(out)
out = self.bn2(out)
out += self.shortcut(x) # 残差连接
out = self.relu(out)
return out
class ChannelAttention(nn.Module):
"""通道注意力机制，增强重要特征"""
def __init__(self, in_channels, reduction_ratio=16):
super(ChannelAttention, self).__init__()
self.avg_pool = nn.AdaptiveAvgPool2d(1)
self.fc = nn.Sequential(
nn.Linear(in_channels, in_channels // reduction_ratio, bias=False),
nn.ReLU(inplace=True),
nn.Linear(in_channels // reduction_ratio, in_channels, bias=False),
nn.Sigmoid()
)
def forward(self, x):
b, c, _, _ = x.size()
y = self.avg_pool(x).view(b, c)
y = self.fc(y).view(b, c, 1, 1)
return x * y.expand_as(x)
class Generator(nn.Module):
def __init__(self, in_channels=3, out_channels=1, hidden_channels=64):
super(Generator, self).__init__()
# 初始卷积层
self.initial = nn.Sequential(
nn.Conv2d(in_channels, hidden_channels, kernel_size=3, stride=1, padding=1),
nn.ReLU(inplace=True),
nn.BatchNorm2d(hidden_channels)
)
# 增强的编码器，使用残差块
self.encoder = nn.Sequential(
ResidualBlock(hidden_channels, hidden_channels),
ResidualBlock(hidden_channels, hidden_channels*2, stride=1),
ChannelAttention(hidden_channels*2), # 通道注意力
ResidualBlock(hidden_channels*2, hidden_channels*4, stride=1),
ChannelAttention(hidden_channels*4), # 通道注意力
ResidualBlock(hidden_channels*4, hidden_channels*8, stride=1),
ChannelAttention(hidden_channels*8), # 通道注意力
)
# 增强的解码器，使用残差块
self.decoder = nn.Sequential(
ResidualBlock(hidden_channels*8, hidden_channels*4, stride=1),
ChannelAttention(hidden_channels*4), # 通道注意力
ResidualBlock(hidden_channels*4, hidden_channels*2, stride=1),
ChannelAttention(hidden_channels*2), # 通道注意力
ResidualBlock(hidden_channels*2, hidden_channels, stride=1),
ChannelAttention(hidden_channels), # 通道注意力
)
# 输出层
self.output = nn.Sequential(
nn.Conv2d(hidden_channels, out_channels, kernel_size=1, stride=1, padding=0),
nn.Sigmoid() # 确保输出在0-1之间
)
def forward(self, x):
x = self.initial(x)
features = self.encoder(x)
out = self.decoder(features)
out = self.output(out)
return out
class Discriminator(nn.Module):
def __init__(self, in_channels=4, hidden_channels=64):
super(Discriminator, self).__init__()
self.conv_layers = nn.Sequential(
nn.Conv2d(in_channels, hidden_channels, kernel_size=3, stride=2, padding=1),
nn.LeakyReLU(0.2, inplace=True),
nn.BatchNorm2d(hidden_channels),
nn.Conv2d(hidden_channels, hidden_channels*2, kernel_size=3, stride=2, padding=1),
nn.LeakyReLU(0.2, inplace=True),
nn.BatchNorm2d(hidden_channels*2),
nn.Conv2d(hidden_channels*2, hidden_channels*4, kernel_size=3, stride=2, padding=1),
nn.LeakyReLU(0.2, inplace=True),
nn.BatchNorm2d(hidden_channels*4),
nn.Conv2d(hidden_channels*4, hidden_channels*8, kernel_size=3, stride=2, padding=1),
nn.LeakyReLU(0.2, inplace=True),
nn.BatchNorm2d(hidden_channels*8),
)
self.fc_layers = nn.Sequential(
nn.Flatten(),
nn.Linear(hidden_channels*8 * 1 * 1, hidden_channels*4),
nn.LeakyReLU(0.2, inplace=True),
nn.Dropout(0.5),
nn.Linear(hidden_channels*4, hidden_channels*2),
nn.LeakyReLU(0.2, inplace=True),
nn.Dropout(0.5),
nn.Linear(hidden_channels*2, 1),
nn.Sigmoid()
)
def forward(self, x):
features = self.conv_layers(x)
output = self.fc_layers(features)
return output
if __name__ == "__main__":
generator = Generator()
discriminator = Discriminator()
gen_input = torch.randn(2, 3, 15, 15)
gen_output = generator(gen_input)
print(f"生成器输入形状: {gen_input.shape}")
print(f"生成器输出形状: {gen_output.shape}")
disc_input = torch.randn(2, 4, 15, 15)
disc_output = discriminator(disc_input)
print(f"判别器输入形状: {disc_input.shape}")
print(f"判别器输出形状: {disc_output.shape}")
6. 脚本执行顺序与作用
6.1 执行顺序
- 模型测试：运行
python model.py，验证模型结构是否正确 - 游戏逻辑测试：运行
python game.py，验证游戏逻辑是否正常 - 模型训练：运行
python train.py，训练GAN模型 - 模型测试：运行
python test.py，测试训练好的模型
6.2 各脚本作用
| 脚本名 | 作用 | 执行命令 |
|---|---|---|
| model.py | 定义GAN模型，包含生成器和判别器 | python model.py |
| game.py | 实现五子棋游戏逻辑，包括落子、胜负判断等 | python game.py |
| utils.py | 提供工具函数，包括棋盘转换、损失计算等 | 被train.py和test.py调用 |
| train.py | 训练GAN模型，保存最佳模型，绘制训练曲线 | python train.py |
| test.py | 测试模型性能，进行AI对战，生成对战结果 | python test.py |
7. 结果分析与可视化
7.1 训练曲线
训练曲线展示了GAN模型在训练过程中的损失变化：
- 生成器损失：随着训练轮数的增加，生成器损失逐渐下降，说明生成器生成的落子位置越来越合理
- 判别器损失：随着训练轮数的增加，判别器损失也逐渐下降，说明判别器的区分能力越来越强
7.2 对战结果
模型训练完成后，我们可以使用test.py脚本进行AI对战，观察AI的表现：
- AI vs AI：让两个AI相互对战，观察它们的策略和表现
- AI vs 人类：人类可以与AI对战，测试AI的棋力
- 自我对弈：AI通过与自己对战不断进化，提高棋力
8. 总结与扩展
8.1 总结
本教程实现了一个基于生成对抗网络的五子棋对战AI，主要内容包括：
- 生成对抗网络的基本原理和架构
- 残差块和注意力机制的应用
- 五子棋游戏逻辑的实现
- GAN模型的训练和测试
- AI对战和自我对弈
8.2 扩展方向
-
模型优化：
- 使用更复杂的注意力机制，如自注意力
- 调整模型超参数，如隐藏层维度、学习率等
- 使用更先进的优化器，如AdamW
-
强化学习结合：
- 结合强化学习方法，如PPO、DQN等
- 实现更有效的自我对弈机制
- 添加奖励函数，引导AI学习更好的策略
-
多智能体系统：
- 实现多个不同策略的AI对战
- 研究AI之间的策略进化和博弈
-
部署应用：
- 将AI部署为网页应用，支持在线对战
- 集成到游戏引擎中，提供更好的用户体验
通过本教程的学习，你应该已经掌握了生成对抗网络的基本原理和实现方法，可以尝试解决更复杂的生成式AI问题。
助力广东及东莞地区开发者，代码托管、在线学习与竞赛、技术交流与分享、资源共享、职业发展，成为松山湖开发者首选的工作与学习平台
更多推荐
30
0- 0
已为社区贡献1条内容
所有评论(0)