南京大学/NJU AI导论 MiniGo 游戏

15:49 2025.12.28

目的：完成蒙特卡洛树搜索

把所有环境 Go, goEnv 和 demo（dqn_vs_random_demo）丢给 ai，让它生成一个 mcts 训练代码。

这个 mcts 不太对劲，为什么 rollout 看起来很不随机啊。

10:47 2025.12.24

目的：写完蒙特卡洛树搜索算法。

第一个难点就是，我们这个算法对外的 API 是什么？就是我们需要实现哪些功能？

根据训练的逻辑，有以下几个接口：

评估局面，对当前局面给出一个评分
落子选择，为当前 player 选择一个落子位置，不过需要注意先后手的问题
训练数据，游戏中的 RL 多半都是与现实环境交互的过程中过程，要以什么样的方式进行训练？
学习统计量数据，例如 loss 什么的

我们再看看 API 是什么？

for ep in range(FLAGS.num_train_episodes):                                                                  # 训练部分
    if (ep + 1) % FLAGS.eval_every == 0:
        losses = agents[playhand].loss
        logging.info("Episodes: {}, Losses: {:.4f}, Rewards: {}, Win Rate: {:.4f}".
                     format(ep + 1, losses, np.mean(ret), np.mean(ret) / 2 + 0.5))
    time_step = env.reset()  # a go.Position object
    while not time_step.last():                                                                             # 游戏部分
        player_id = time_step.observations["current_player"]
        agent_output = agents[player_id].step(time_step)                                                    # 由当前玩家的 agent 选择动作
        action_list = agent_output.action                                                                   # 狗屎变量名设计，哪个人写的代码？
        time_step = env.step(action_list)
    for agent in agents:                                                                                    # 游戏结束，所有 agent 用最终状态更新一次
        agent.step(time_step)
    if len(ret) < max_len:
        ret.append(time_step.rewards[0])
    else:
        ret[ep % max_len] = time_step.rewards[0]

ret = []
for ep in range(FLAGS.num_eval):                                                                            # 评估部分
    time_step = env.reset()
    while not time_step.last():
        player_id = time_step.observations["current_player"]
        agent_output = agents[player_id].step(time_step, is_evaluation=True, add_transition_record=False)   # 评估时不记录转移
        action_list = agent_output.action
        time_step = env.step(action_list)

    # Episode is over, step all agents with final info state.
    # for agent in agents:
    agents[playhand].step(time_step, is_evaluation=True, add_transition_record=False)
    agents[1 - playhand].step(time_step)
    ret.append(time_step.rewards[0])
print(np.mean(ret))

20:44 2025.12.22

刚才花费一个小时基本理解了模板代码，下一步就是熟悉 RL 算法在提供的围棋环境下训练的方法，策略网络、值函数网络模型保存的方式

计划阅读 a2c_vs_random 和 dqn_vs_random

经过阅读，俩 demo 内容基本一致，主要要看 algorithms/ 里面的写法，不过我大概也能预料到。

dqn agent 的建立参数：

    def __init__(self,
                 session,                           //使用 tensorflow 的会话
                 player_id,                         //0 表示黑棋先手，1 表示白棋后手
                 state_representation_size,         //棋盘大小（边长平方）
                 num_actions,                       //可行动空间大小，上面+1
                 hidden_layers_sizes,               //后面是学习相关的，前面是游戏相关的
                 replay_buffer_capacity=10000,
                 batch_size=128,
                 replay_buffer_class=ReplayBuffer,
                 learning_rate=0.01,
                 update_target_network_every=200,
                 learn_every=10,
                 discount_factor=1.0,
                 min_buffer_size_to_learn=1000,
                 epsilon_start=1.0,
                 epsilon_end=0.1,
                 epsilon_decay_duration=int(1e6),
                 optimizer_str="sgd",
                 loss_str="mse",
                 max_global_gradient_norm=None):

需要注意的是，这里使用 tensorflow 来进行训练，需要是不是 sess.run 才对。

在 algorithms/ 文件夹下的 agent 的类中都有英文的参数解释。我打算阅读 dqn.py 而不读另一个，因为我只打算看看训练范式是怎样的，例如接口等是如何调用的。

19:50 2025.12.22

刚才还是不太冷静，浪费太多时间了。

说说 GoEnv 的 API：

env = Go()，初始化
moves = env.get_all_legal_moves()，当前合法移动，此为 26 维列表，表示 25+1(PASS) 个行动，这是 5*5 棋盘的情况
timestep = env.step(fcoord)，执行 fcoord(0~25) 移动并返回对应的信息，这个信息有点复杂

TimeStep(
  observations={
    'info_state': [array(...), array(...)],             //两个东西一样的，0 表示空，1 表示一方，2 表示另一方
    'legal_actions': [array(...), array(...)],          //玩家 0/1 的可行步骤，以列表把所有可行步骤给出，而非 01 编码
    'current_player': 0                                 //当前玩家是谁
  },
  rewards=[-1, 1],                                      //当 step_type=2 时不为 0，表示先后手的奖励
                                                        //两者为 [result, -result]，而 result 表示黑子的分数
  discounts=[1.0, 1.0],                                 //赢的奖励为 1
  step_type=<StepType.LAST: 2>                          //0 1 2 分别表示开局，中局，结局
)

print(env.get_current_board())，输出棋盘的可视化形态
if timestep.last()，如果成立则表示游戏结束
timestep = env.reset()，重置棋盘 //这里的 timestep，

17:42 2025.12.22

我草太傻逼了这个模板代码。拉下来到处都不能运行，test_GoEnv.py 一运行，哈哈，一次就结束了。

17:19 2025.12.22

粗略制定计划.

总目标：结合MCTS、强化学习和 Self Play等技术，实现一个简单的围棋 AI 程序。参考其中使用的强化学习算法，并结合 MCTS/ Self Play 方法，完成 AlphaGo / AlphaGo Zero 框架

step1 熟悉与围棋环境的数据交互方式
step2 熟悉 RL 算法在提供的围棋环境下训练的方法，策略网络、值函数网络模型保存的方式
step3 在这里实现 MCTS 算法（有较多技术细节）

16:14 2025.12.22

目的：熟悉项目架构，规划人物

项目结构：

agent\
algorithms\
environment\
test\
a2c_vs_random_demo.py
dqn_vs_random_demo.py
rl_loop.py

agent\ 文件夹里面是 ai agent，现在已经实现了 RandomAgent

algorithms\ 文件夹里面是完整的强化学习智能体实现示范代码，分别实现了 A2C 和 DQN 算法，并且可以直接用于围棋环境 GoEnv.py

environment\ 里面有围棋环境，让 ai 总结了一下需要留意的 api：

你需要重点关注环境目录（如 GoEnv.py、go.py）中与智能体交互相关的 API，尤其是：

需要留意的 API：
GoEnv 或 Go 类的初始化方法（如 __init__），了解如何创建环境实例。
reset() 方法：重置环境，返回初始状态。
step(action) 方法：执行一步动作，返回新的状态、奖励、是否结束等信息。
状态表示（如 info_state）、动作空间（如 action_size）、奖励（如 rewards）、合法动作（如 legal_actions）。
last() 或类似方法：判断当前是否为终局。
observations 字典：通常包含当前玩家、状态、合法动作等。

不需要重点关注的内容：
具体棋盘坐标转换、底层棋规实现（如 coords.py），除非你要修改规则或做可视化。
环境内部的调试、日志、缓存等辅助函数。
__pycache__ 文件夹和编译缓存。

总结：
只要你能正确调用 reset()、step(action)，并能获取当前状态、奖励、合法动作等信息，就能完成 RL 智能体的训练和评估。
底层实现细节和辅助工具不是你实现 RL 算法时的重点。

test\ 里面主要用于测试围棋环境和智能体的实现是否有问题：

random_test.py：用两个随机智能体（RandomAgent）在围棋环境中对弈，主要用于测试环境和随机智能体的交互，输出每步的状态和最终奖励。适合做环境和 agent 的基础功能验证。
test_GoEnv.py：直接测试围棋环境（GoEnv），每步随机选择一个合法动作，打印动作和棋盘状态。用于验证环境的合法动作生成、棋盘状态更新等底层功能。

以及主目录下的三个 .py 文件：*_demo 的文件如名字所述，rl_loop 和 random_test 基本一致。

ok 差不多明白了项目架构，试了试 dqn_vs_random_demo.py，不多说了，很变态的结果：

I1222 16:52:44.470135 20672 dqn_vs_random_demo.py:76] Episodes: 2000: Losses: 0.19456958770751953, Rewards: 0.0525
I1222 16:53:00.798449 20672 dqn_vs_random_demo.py:76] Episodes: 4000: Losses: 0.0926736444234848, Rewards: 0.17
I1222 16:53:21.134136 20672 dqn_vs_random_demo.py:76] Episodes: 6000: Losses: 0.010782426223158836, Rewards: 0.428
I1222 16:53:44.453741 20672 dqn_vs_random_demo.py:76] Episodes: 8000: Losses: 0.017675992101430893, Rewards: 0.561
I1222 16:54:10.753086 20672 dqn_vs_random_demo.py:76] Episodes: 10000: Losses: 0.024320190772414207, Rewards: 0.609
I1222 16:54:36.252039 20672 dqn_vs_random_demo.py:76] Episodes: 12000: Losses: 0.018487652763724327, Rewards: 0.648
I1222 16:55:01.740851 20672 dqn_vs_random_demo.py:76] Episodes: 14000: Losses: 0.043636564165353775, Rewards: 0.643
I1222 16:55:27.086409 20672 dqn_vs_random_demo.py:76] Episodes: 16000: Losses: 0.05140334367752075, Rewards: 0.631
I1222 16:55:52.661696 20672 dqn_vs_random_demo.py:76] Episodes: 18000: Losses: 0.5933258533477783, Rewards: 0.556
I1222 16:56:31.028793 20672 dqn_vs_random_demo.py:76] Episodes: 20000: Losses: 150.72731018066406, Rewards: 0.336
I1222 16:57:36.566048 20672 dqn_vs_random_demo.py:76] Episodes: 22000: Losses: 1768.912353515625, Rewards: 0.136
I1222 16:58:55.836867 20672 dqn_vs_random_demo.py:76] Episodes: 24000: Losses: 6158.42626953125, Rewards: 0.091
I1222 16:59:57.498176 20672 dqn_vs_random_demo.py:76] Episodes: 26000: Losses: 77672.9375, Rewards: 0.039

11:58 2025.12.21

目的：熟悉项目架构

posted @ 2025-12-22 11:59 哼唧昂叽阅读(34) 评论(0) 收藏举报

刷新页面返回顶部

fengjianming

南京大学/NJU AI导论 MiniGo 游戏

公告