目录
1.AlphaGo介绍
2.AlphaGo核心原理
3.程序思路
3.1生成棋盘(data_board.py)
3.2 生成器(generator.py)
3.3 判别器(discriminator.py)
3.4 训练模型(train.py)
4.模型调用
5.运行结果
6.总结
1.AlphaGo介绍
AlphaGo是一款由谷歌DeepMind公司研发的围棋人工智能程序，AlphaGo基于深度学习和强化学习的技术。最早亮相于2015年，当时DeepMind首次展示了它战胜世界冠军李世石的成就，这一突破性成果引起了全球关注，也推动了人工智能特别是围棋领域的发展。
2.AlphaGo核心原理
-
深度神经网络 (Deep Neural Network): AlphaGo利用了深度卷积神经网络（CNN）来识别棋盘上的模式和潜在的战略优势。这种网络能够从大量的历史棋局中学习，并形成一种对棋局状态的内在理解。
-
蒙特卡洛树搜索(MCTS): 这是一种搜索算法，结合了神经网络评估的优势。AlphaGo通过模拟无数种可能的游戏走法，并利用神经网络预测每一步后的胜率，选择最有可能获胜或导致最少损失的策略。这被称为"启发式下的探索"。
-
自我对弈(self-play): AlphaGo的关键在于大量自我对弈过程，它通过不断与改进版的自己对战来提升能力。每一次对局都会反馈到模型的训练过程中，使得模型逐步优化。
-
融合策略和价值判断: AlphaGo采用了两种网络架构——策略网络（Policy Network）用于选择下一步落子，以及估值网络（Value Network）用于估计当前局面的优劣。两者相辅相成，共同驱动决策。
3.程序思路
首先按照指定的围棋规则生成一个棋盘，然后基于生成对抗神经网络通过设置指定的生成器和判别器，再进行模型训练。
3.1生成棋盘(data_board.py)
import numpy as np# 假设生成 100 个随机棋盘状态
board_states = np.random.choice([1, 0, -1], size=(100, 19, 19))# 保存棋盘数据
np.save('board_states.npy', board_states)
3.2 生成器(generator.py)
import tensorflow as tf
from tensorflow.keras import layersdef build_generator(input_shape=(100,)): # 输入噪声形状，例如 (100,)model = tf.keras.Sequential()# 第一层，输入噪声，Dense 层输出大小为 19*19*64model.add(layers.Dense(19 * 19 * 64, activation='relu', input_shape=input_shape))# 扁平化输出并 Reshape 成 19x19 的特征图model.add(layers.Reshape((19, 19, 64)))# 卷积层，用于生成最终棋盘model.add(layers.Conv2DTranspose(64, kernel_size=3, strides=1, padding='same', activation='relu'))model.add(layers.Conv2DTranspose(32, kernel_size=3, strides=1, padding='same', activation='relu'))model.add(layers.Conv2D(1, kernel_size=3, strides=1, padding='same', activation='tanh')) # 单通道输出return model
3.3 判别器(discriminator.py)
import tensorflow as tf
from tensorflow.keras import layersdef build_discriminator(input_shape=(19, 19, 1)):model = tf.keras.Sequential()# 卷积层处理输入棋盘model.add(layers.Conv2D(64, kernel_size=3, strides=2, padding='same', input_shape=input_shape))model.add(layers.LeakyReLU(alpha=0.2))model.add(layers.Conv2D(128, kernel_size=3, strides=2, padding='same'))model.add(layers.LeakyReLU(alpha=0.2))model.add(layers.Flatten())model.add(layers.Dense(1, activation='sigmoid')) # 最终输出二分类，真或假return model
3.4 训练模型(train.py)
import tensorflow as tf
from tensorflow.keras.optimizers import Adam
from generator import build_generator
from discriminator import build_discriminator
import numpy as np
import osdef train_gan(epochs, batch_size, save_interval=1000):# 初始化生成器和判别器generator = build_generator(input_shape=(100,))discriminator = build_discriminator((19, 19, 1))# 构建生成对抗网络gan = tf.keras.Sequential([generator, discriminator])discriminator.compile(optimizer=Adam(), loss='binary_crossentropy')gan.compile(optimizer=Adam(), loss='binary_crossentropy')# 加载棋盘数据board_data = np.load('board_states.npy') #更改成棋盘的路径for epoch in range(epochs):# 生成随机噪声noise = np.random.normal(0, 1, (batch_size, 100))# 使用生成器生成棋盘generated_boards = generator.predict(noise)# 随机选择真实棋局real_boards = board_data[np.random.randint(0, board_data.shape[0], size=batch_size)]# 训练判别器discriminator_loss_real = discriminator.train_on_batch(real_boards, np.ones((batch_size, 1)))discriminator_loss_fake = discriminator.train_on_batch(generated_boards, np.zeros((batch_size, 1)))# 训练生成器gan_loss = gan.train_on_batch(noise, np.ones((batch_size, 1)))if epoch % 100 == 0:print(f"Epoch {epoch}, D Loss Real: {discriminator_loss_real}, D Loss Fake: {discriminator_loss_fake}, G Loss: {gan_loss}")# 每隔一定的 epoch 保存模型if epoch % save_interval == 0:save_model(generator, discriminator, epoch)# 在训练完成时保存最终模型save_model(generator, discriminator, 'final')def save_model(generator, discriminator, epoch):model_dir = 'alphago/data' #设置训练后的模型储存路径if not os.path.exists(model_dir):os.makedirs(model_dir)generator_path = os.path.join(model_dir, f'generator_{epoch}.h5')discriminator_path = os.path.join(model_dir, f'discriminator_{epoch}.h5')generator.save(generator_path)discriminator.save(discriminator_path)print(f"Models saved: Generator -> {generator_path}, Discriminator -> {discriminator_path}")if __name__ == "__main__":train_gan(epochs=2000, batch_size=32, save_interval=1000)
4.模型调用
调用训练后的模型进行人机测试。
import numpy as np
from tensorflow.keras.models import load_model
import random
import matplotlib.pyplot as plt# 初始化 19x19 的围棋棋盘，0 表示空，1 表示黑子，-1 表示白子
def init_board():return np.zeros((19, 19), dtype=int)# 打印棋盘
def print_board(board):for row in board:print(" ".join(['.' if x == 0 else ('●' if x == 1 else '○') for x in row]))# 检查落子是否有效
def is_valid_move(board, x, y):return 0 <= x < 19 and 0 <= y < 19 and board[x][y] == 0# 人类落子
def human_move(board):while True:try:move = input("请输入落子位置 (格式: x y): ").split()x, y = int(move[0]), int(move[1])if is_valid_move(board, x, y):board[x][y] = 1 # 黑子returnelse:print("无效落子，请重新输入。")except (ValueError, IndexError):print("请输入合法的 x y 坐标。")# 计算机通过生成器模型落子
def ai_move(board, generator):# 将棋盘展平作为生成器的输入，生成器根据当前棋局生成新棋盘input_noise = np.random.normal(0, 1, (1, 100)) # 噪声输入generated_board = generator.predict(input_noise)[0, :, :, 0]# 将生成的棋盘转化为合法落子位置，选择空位中最大的值作为落子点empty_positions = np.argwhere(board == 0)move_scores = [(pos, generated_board[pos[0], pos[1]]) for pos in empty_positions]best_move = max(move_scores, key=lambda x: x[1])[0]# 计算机在最佳位置落子board[best_move[0]][best_move[1]] = -1 # 白子print(f"AI 落子: ({best_move[0]}, {best_move[1]})")# 判断棋局是否结束
def check_winner(board):# 此处可以实现胜负判定逻辑，例如目数计算或简单的终局判断# 暂时可以使用较简单的胜负规则：返回 None 表示未分胜负，返回 1 或 -1 表示某方胜利return None# 主程序：围棋人机对弈
def play_go():board = init_board() # 初始化棋盘generator = load_model('data/generator_final.h5') # 加载训练好的生成器模型turn = 0 # 0 表示玩家先手，1 表示 AI 先手while True:print_board(board) # 打印棋盘winner = check_winner(board) # 判断是否胜负已分if winner is not None:print(f"胜者: {'黑子' if winner == 1 else '白子'}")breakif turn % 2 == 0:print("轮到玩家落子 (黑子):")human_move(board) # 玩家落子else:print("轮到 AI 落子 (白子):")ai_move(board, generator) # AI 落子turn += 1 # 切换回合if __name__ == "__main__":play_go()
5.运行结果
运行模型调用的代码，可以实现人机对抗，输入落子的X和Y的值，机器识别后进行预测然后机器落子，进行人机交互。
6.总结
利用python语言进行AlphaGo的框架搭建，实现围棋对抗的一个大模型搭建。
运行流程：生成棋盘（data_board.py)——模型训练（train.py）——模拟人机交互（play_go.py）
