当前位置： 首页 > article >正文

AlphaGo围棋模型——基于python语言

article 2024/12/25 14:20:53

目录

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核心原理

  1. 深度神经网络 (Deep Neural Network): AlphaGo利用了深度卷积神经网络（CNN）来识别棋盘上的模式和潜在的战略优势。这种网络能够从大量的历史棋局中学习，并形成一种对棋局状态的内在理解。

  2. 蒙特卡洛树搜索(MCTS): 这是一种搜索算法，结合了神经网络评估的优势。AlphaGo通过模拟无数种可能的游戏走法，并利用神经网络预测每一步后的胜率，选择最有可能获胜或导致最少损失的策略。这被称为"启发式下的探索"。

  3. 自我对弈(self-play): AlphaGo的关键在于大量自我对弈过程，它通过不断与改进版的自己对战来提升能力。每一次对局都会反馈到模型的训练过程中，使得模型逐步优化。

  4. 融合策略和价值判断: 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 layers

def build_generator(input_shape=(100,)):  # 输入噪声形状，例如 (100,)
    model = tf.keras.Sequential()

    # 第一层，输入噪声，Dense 层输出大小为 19*19*64
    model.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 layers

def 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 os

def 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  # 黑子
                return
            else:
                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 '白子'}")
            break

        if 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）


http://www.kler.cn/a/288954.html

相关文章：

  • 重温设计模式--享元模式
  • 项目代码第6讲：UpdownController.cs；理解 工艺/工序 流程、机台信息；前端的“历史 警报/工艺 记录”
  • NACA四位数字翼型
  • 2.Couchbase 的增量查询优化
  • vulnhub靶场【WhowWantsToBeKing】之1
  • K8s HPA的常用功能介绍
  • 交叉编译 gdb
  • HarmonyOS开发实战（ Beta5版）优化实践/合理使用缓存提升性能
  • Linux 命令行快捷键
  • Netty Reactor面试连环问
  • 学习笔记 ---- 莫比乌斯反演总结
  • Spring Boot 入门
  • 5款手机版的影视解说文案生成器，无须下载更方便！
  • linux下cpu多核运行程序以及运行时间统计
  • 物联网（IoT）支持的小型水处理厂实时硬件在环（HIL）仿真
  • 角谷猜想——考拉兹猜想
  • 《OpenCV计算机视觉》—— 图像边缘检测
  • day4 C++
  • 【STM32】IIC
  • mongodb 在 Windows 环境下迁移数据库的问题
  • Linux：手搓shell
  • 解析淘宝商品详情API返回值中的特殊属性
  • python系列教程231——__init__.py
  • Docker php文件本地包含--pearcmd.php利用
  • Prometheus+Grafana监控数据可视化
  • 反序列化漏洞（一）