翻译Deep Learning and the Game of Go（11）第九章：靠实践学习：强化学习

本章包括：

1. 为强化学习定义一个任务
2. 为游戏构建一个学习代理
3. 为训练收集自我游戏经验

我可能已经读过十几本关于围棋的书，这些书都是由来自中国、韩国和日本的强大专业人士写的，但我依旧只是一个中等的业余棋手。为什么我没有达到和这些传奇一样的水平呢？是因为我忘记他们的课程吗？不是这样的；我实际上可以背诵Toshiro Kageyama对于围棋基础的一些经验，也许我只需要读更多的书.。

我不知道成为顶级围棋高手的全部秘方，但我至少知道我和围棋专业人士的一个区别：练习。围棋棋手在获得专业资格之前，至少需要练五千到一万盘。实践创造知识，有时这是你无法直接交流的知识。你可以总结这种知识——这就是围棋书籍存在的意义。如果我希望掌握我读过的课程，我需要投入类似的练习时间。

如果练习对人类如此宝贵，那么对于计算机呢？计算机程序能通过练习来学习吗？这就是强化学习的真谛。在强化学习（R L）中，您通过反复尝试一个任务来改进一个程序。当它有良好的结果，您可以修改程序以重复这种决定。当它有坏的结果时，您可以修改程序以避免这些决定。这并不意味着在每次试验之后都要编写新代码：RL算法提供了进行这些修改的自动化方法。

强化学习使用起来并不轻松。首先，它很慢：你的机器人需要玩成千上万的游戏才能有所长进。此外，训练过程非常繁琐，难以调试。但是，如果你努力将这些技术融入到你的AI中，回报是巨大的。你可以构建一个使用复杂策略的软件去处理一系列任务，即使你自己不知道其策略

本章就介绍强化学习的周期。接下来，你将看到如何建立一个围棋机器人，让它以一种适合强化学习的方式与自己对抗。第10章就展示了如何使用自我对弈的数据去提高机器人的性能。 

9.1 强化学习周期 

许多算法实现了强化学习的力学，但它们都在标准框架内工作。本节描述强化学习周期，其中计算机程序通过反复尝试一项任务来改进。图9.1说明了周期。 

图9.1.  强化学习周期:可以通过多种方式实现强化学习，但整体过程有共同的结构。首先，计算机程序尝试重复一个任务。这些尝试的记录被称为经验数据。接下来，您修改行为以模仿更成功的尝试；这个过程是训练。然后你会定期评估确认程序正在改进。通常，您需要重复这个过程多次。 

在强化学习中，您的围棋AI是一个为了完成任务而做出决策的程序。在本书的前面部分，您实现了选择围棋落子的各种版本的Agent。在这些情况下，你给AI提供了一个GameState对象，使它可以用一个决定(即一个落子)来回应。尽管你那时没有使用强化学习，但AI的原理是一样的。

强化学习的目标是使AI尽可能有效。在这种情况下，你想让你的AI去赢。

首先，你让你的围棋AI跟自己玩了一批游戏；在每一场比赛中，它应该记录每一个回合和最后的结果。这些游戏记录被称为它的经验。

接下来，你通过在其自我对弈过程中发生的事情去更新AI的行为来训练你的AI。这一过程类似于第6章和第7章所涵盖的神经网络的训练。这个核心思想是，你希望AI能够重复它在赢棋中做出的决定，并停止在它输棋中做出的决定。训练算法作为一个软件包来处理你AI的结构：为了训练你需要能够系统地修改你的AI行为。有许多算法都可以做到这一点；我们在这本书中涵盖了三个算法。在这一章和接下来的一章，我们将学习策略梯度算法。在第11章中，我们将讨论Q-learning算法。第12章将介绍actor-critic算法。

训练后，你希望你的机器人能够更强大。但是训练过程有很多地方会出错，因此评估机器人的进展以确认其实力是个好主意。要评估一个玩游戏的AI，需要让它玩更多的游戏。您可以将你的AI与早期版本进行对弈，以衡量其水平。要做一个全面的测试，你也可以定期将你的AI与其他AI或你进行对弈

然后你可以无限期地重复整个周期：

• 收集经验
• 训练
• 评估

我们将把这个周期分成多个脚本。在本章中，您将实现一个自我对弈脚本，该脚本将模拟自我对弈，并将经验数据保存到磁盘。在下一章中，您将制作一个训练脚本，将经验数据为输入，相应地更新AI，并保存新的AI

9.2.什么将成为经验？ 

在第三章中，您设计了一组用于表示围棋游戏的数据结构。您可以想象如何通过使用诸如Move、GoBoard和GameState等类来存储整个游戏记录。而强制学习算法是通用的：它们处理一个问题的高度抽象表示，因此相同的算法可以应用于尽可能多的问题领域。本节就展示如何使用强化学习的语言来描述游戏记录。

在玩游戏的情况下，你可以把你的经验分为个人游戏和一段变化。每一个变化都有一个明确的结局，一个变化做出的决定不会影响另一个变化的决定。在其他领域，你可能没有任何明显的方法来把经验分成各种变化；例如，一个机器人，被设计用来连续操作，去做无止尽的决策。你仍然可以将强化学习应用于这类问题，但这里的变化边界使它变得更简单。

在一个变化中，一个AI面临着它的环境状态。基于当前状态，AI必须选择一个动作。在选择一个动作后，AI将看到一个新的状态；下一个状态取决于无论是选择的行动和环境中发生的其他事情。在围棋中，您的AI将看到一个棋盘盘面（状态），然后选择一个合法的落子。在那之后，AI将在下一个回合中看到一个新的棋盘局面。

注意，在AI选择一个落子后，下一个状态也包括对手的落子。你无法根据当前的游戏状态去确定下一个状态以及您要选择的落子：您还必须等待对手的落子。对手的行为也是环境的一部分，你的AI必须学会适应。

为了提升水平，你的AI需要反馈它是否达到了目标。你可以通过计算它的回报来提供反馈，这是一个达到目标的分数。对于你的围棋AI来说，目标是赢得对局，你可以在它赢一局棋时加1，以及在其输一局时减1。强化学习算法将改变AI的行为，从而增加它的回报量。图9.2说明了如何用状态、动作和奖励来描述围棋游戏。

图9.2，一个5*5的游戏，围棋翻译成强化学习的语言..你想训练的是黑棋。它看到一系列状态（棋盘局面）并选择落子（合法落子）。在一个变化（一个完整的游戏）结束时，它将得到一个奖励，以表明它是否达到了它的目标。在这种情况下，黑色赢得了游戏，所以给它奖励了1。

围棋和类似的游戏都是特殊情况：在游戏结束时计算一次回报，而回报只有两种可能：你赢了或输了，你不在乎游戏中还会发生什么情况。在其他领域，回报可能会分散开来。想象一下让AI玩拼字游戏。在每一个回合中，AI都会放置一个单词和积分，然后它的对手也会做同样地事情。在这种情况下，您可以计算人工智能积分的正回报，以及对手积分的负回报。然后人工智能就不需要一直等到一个变化结束后才能得到回报；在它采取的每一个落子之后，它都会得到很少的回报。

强化学习的一个关键思想是，一个行动可能要为一个回报负责，而这个回报要晚得多。想象一下你在一个对局中第35步下了一个聪明的落子，并继续下200步后获胜。那该棋局的早期阶段落子至少得为这场胜利赢得一些赞誉。你必须以某种方式来奖励游戏中的所有落子。你的AI在一个落子之后看到的未来回报就称为该落子的回报。为了计算一个动作的回报，你需要在把这一行动之后直到对局结束的所有回报加起来，如下面代码所示。这是一种方式，你实现并不知道，哪些落子是可以赢或输。他通过学习算法，以区分信任或指责个别落子。 

for exp_idx in range(exp_length): 
    #reward[i]是在落子i后立马看到的回报
    total_return[exp_idx] = reward[exp_idx] 
    for future_reward_idx in range(exp_idx + 1, exp_length): 
        #在所有未来的回报上循环遍历，并将它们添加到当前回报中
        total_return[exp_idx] += reward[future_reward_idx] 

这一假设并不能解释每一个问题。再想想我们的拼字游戏例子，你第一轮的决定可能会影响你第三轮的得分，但很难看出你第三轮的决定会如何影响你的第二十轮。为了表示这种概念，您可以计算每个动作的未来回报加权和。当你离动作更远的时候，权重应该会变小，这样未来的回报就会比立即的回报影响更少。

这种技术叫做折扣奖励。下面代码就展示了如何计算折扣收益。在这个例子中，每一个动作都会立即得到全部的回报。但下一步的回报只能有75%那么多；两步的回报计算出来只能有75%×75%=56%那么多，以此类推。选择75%只是一个例子；正确的折扣率将取决于你的特定域，你可能需要进行一点实验才能找到最有效的数字。

for exp_idx in range(exp_length):
    discounted_return[exp_idx] = reward[exp_idx] 
    discount_amount = 0.75
    # 折扣率会越来越小，当你从原来的动作中得到进一步的时候.
    for future_reward_idx in range(exp_idx + 1, exp_length): 
       discounted_return[exp_idx] += discount_amount * reward[future_reward_idx] 
       discount_amount *= 0.75

在建立围棋AI的情况下，唯一可能的回报是输赢。这可以让您在返回计算中走了捷径。当你的AI获胜时，游戏中的每一个落子都有1的回报。当你的AI输了，每个落子都有-1的回报。

9.3.建造一个可以学习的AI 

强化学习不能凭空创建一个围棋AI，或任何其他类型的AI。它只能提升一个已经在游戏参数范围内工作的AI。开始阶段，你需要一个至少可以完成一个完整游戏的AI。本节就演示了如何创建一个围棋AI通过使用神经网络来选择落子。如果你从一个未经训练的网络开始，AI就会玩得跟你第三章的随机落子AI一样糟糕。以后可以通过强化学习来完善这个神经网络

一个策略是对于一个给定状态去选择操作的函数。前几章您看到了Agent类的几个实现，它们具有select_move函数。每个select_move函数都是一个策略：一个游戏状态输入进来，然后输出一个落子。从他们产生合法的落子来说，至今你实现的所有策略都是有效的。但它们并不是同样好：第4章中的MCTSAgent将经常地击败第3章中的RandomAgent。.如果您想提高这些AI中的一个，您需要考虑改进算法，编写新的代码，并测试它-----标准软件开发过程。

为了使用强化学习，您需要一个可以使用另一个计算机程序自动更新的策略。在第6章中，你研究了一类函数，让你精确地做到这一点：卷积神经网络。一个深度神经网络可以计算复杂的逻辑，并且可以使用梯度下降算法修改其行为。

你在第六章和第七章中设计的落子预测神经网络输出了带有棋盘上每个点预测值的向量；该值表示该点将是下一个落子的概率。如何根据这样的输出形成策略？一种方法是简单的选择具有最高值的落子。如果您的网络已经被训练来选择好的落子，这将产生良好的结果。但对于任何给定的棋盘局面，它都会选择相同的落子，这就产生了强化学习的问题。要通过强化学习来提高，需要选择多种落子，有的会更好，有的会更坏；你可以观察他们产生的结果来检测落子。但你为了提高必须要多种变化。

不要每次选择最高概率的落子，你想要一个随机策略。这里，随机意味着如果您输入了两次完全相同的棋盘局面，您的AI可以选择不同的落子。这涉及到了随机性，但不与第三章中的随机落子AI采用相同的方式。RandomAgent选择落子时根本不考虑游戏中发生的事情，而随机策略意味着您的落子选择将取决于棋盘状态，但它不会100%可预测。 

 9.3.1.从概率分布中采样

对于任何棋盘局面，你的神经网络都会给您提供一个向量，使得每个元素对应一个棋盘局面。若要从中创建策略，可以对于向量中的每个元素都视为指示你选择一个特定落子的可能性。本节演示如何根据这些概率来选择落子。

例如，如果你在玩石头剪刀布，你可以遵循选择50%的时间出石头，30%的时间出布，20%的时间出剪刀。50%~30%~20%的分割是三种选择的概率分布。注意概率和正好是100%：这是因为您的策略必须始终从这三个中选择一个。这是概率分布的一个必要属性；50%~30%~10%的政策将会让你在10%的时间做不出决定。

从这些概率分布中随机选择其中一个的过程称为抽样。下面的代码就显示了这样一个Python函数，它将根据该策略选择其中一个选项。

import random def rps():
  randval = random.random() 
  if 0.0 <= randval < 0.5: 
      return 'rock'
  elif 0.5 <= randval < 0.8:
      return 'paper' 
  else:
      return 'scissors'

尝试运行上面的代码，你会看到比布更多的石头，比剪刀更多的布，但三者都会定期出现。

从概率上取样的逻辑分布被构建到NumPy中，作为np.random.choice函数。下面的列表显示了使用NumPy实现的完全相同的行为

import numpy as np


def rps():
    return np.random.choice( ['rock', 'paper', 'scissors'], p=[0.5, 0.3, 0.2])

 此外，np.random.choice将处理来自同一分布的重复采样。它将从您的分布中采样一次，并从列表中删除该项目，并从其余的项目中再次采样。在这种情况下，你就得到了一个半随机有序列表。高概率项目很可能出现在榜单的前几位，但仍有一些变化。下面的列表展示了如何使用np.random.choice进行重复采样。您指示size=3表示您想要三个不同的项，并写replace=false表示您不希望重复任何结果。

import numpy as np


def rps():
    return np.random.choice( ['rock', 'paper', 'scissors'], size=3, replace=False, p=[0.5, 0.3, 0.2])

 如果您的围棋策略推荐了一个无效移动，则重复采样将是有用的。在这种情况下，你会想选择另一个。你可以调用np.random.choice一次，然后沿着它生成的列表去工作。

9.3.2.剪辑概率分布 

强化学习过程可能相当不稳定，特别是在早期。AI可能对几次获胜的机会反应过度，并暂时将很高的概率分配给那些不是真正很 好的落子。（在这方面，这和人类初学者没有什么不同！）一个特定的移动概率一直到1是可能的。这就造成了一个微妙的问题：因为你的AI总是选择相同的落子，它没有机会去忘记它。

为了防止这种情况，您将剪辑概率分布，以确保没有概率被推到0或1。你在第八章的深度学习AI做了相同的事情。来自NumPy的np.clip函数处理这里的大部分工作。

import numpy as np


def clip_probs(original_probs):
    min_p = 1e-5
    max_p = 1-min_p
    clipped_probs = np.clip(original_probs, min_p, max_p)
    # 确保结果仍然是有效的概率分布
    clipped_probs = clipped_probs / np.sum(clipped_probs)
    return clipped_probs

9.3.3.初始化AI

让我们开始构建一种新的AI，一种策略AI，它将根据随机策略选择移动，并且可以从经验数据中学习。这个模型可以与来自第6章和第7章的落子预测AI同一；唯一的区别是你训练它的方式。您可以将dlgo/agent/pg.py模块添加到dlgo库中。

回想先前的章节，你的模型需要一种匹配的棋盘编码方案。PolicyAgent类可以在构造函数中接受模型和棋盘编码器。这创造了一个很好的分离。这个PolicyAgent类负责根据模型来选择落子，并根据其经验来改变其行为。但它可以忽略模型结构和棋盘编码方案的细节。

from dlgo.agent.base import Agent


class PolicyAgent(Agent):

    def __init__(self, model, encoder):
        super().__init__()
        #eras顺序模型实例
        self.model = model
        #编码器
        self.encoder = encoder

要启动强化学习过程，首先要构造一个棋盘编码器，然后是一个模型，最后是代理。下面的代码就显示了这个过程。 

from dlgo.Encoder.ElevenEncoder import ElevenPlaneEncoder
from keras.models import Sequential
from dlgo.network.LargeLayer import layers
from keras.layers import Dense
from keras.layers import Activation
from dlgo.agent.PolicyAgent.PolicyAgent import PolicyAgent

board_size = 19
encoder = ElevenPlaneEncoder(board_size)
#构建顺序神经网络
model = Sequential()
for layer in layers(encoder.shape()):
    model.add(layer)
# 添加一个输出层，该层将在返回棋盘上点的概率分布
model.add(Dense(encoder.num_points()))
model.add(Activation('softmax'))
new_agent = PolicyAgent(model, encoder)

当您使用新创建的模型构造这样的代理时，Keras将模型权重初始化为小的随机值。在这一点上，代理的策略将接近统一的随机：它会以大致相等的概率选择任何有效的落子。然后，训练其模型将为其决策添加结构。

 9.3.5.实现落子选择

在开始自我对弈之前，PolicyAgent还需要实现1一个函数：select_move。此函数将类似于DeepLearningAgent中的select_move函数。第一步是将棋盘编码为一个张量（一堆矩阵；见附录A），适合输入给模型。接下来，你把棋盘的张量输入到模型中，然后就会得到一个落子概率分布，之后对分布进行裁剪，以确保没有概率一直到1或0。图9.3说明了这一过程的流程。清单9.12显示了如何实现这些步骤，几乎和DeepLearningAgent一样

   # 返回整个棋盘预测概率分布
    def predict(self, game_state):
        encoded_state = self.encoder.encode(game_state)
        input_tensor = np.array([encoded_state])
        return self.model.predict(input_tensor)[0]

    #裁剪概率分布
    def clip_probs(original_probs):
        min_p = 1e-5
        max_p = 1 - min_p
        clipped_probs = np.clip(original_probs, min_p, max_p)
        # 确保结果仍然是有效的概率分布
        clipped_probs = clipped_probs / np.sum(clipped_probs)
        return clipped_probs

    def select_move(self, game_state):
        num_moves = self.encoder.board_width*self.encoder.board_height
        # 获得预测概率分布
        move_probs = self.predict(game_state)

        # 裁剪概率分布
        move_probs = self.clip_probs(move_probs)

        # 把概率转成一个排序列表(0-360)
        candidates = np.arange(num_moves)
        # 按照落子概率进行采样，不允许取相同的落子
        ranked_moves = np.random.choice(
            candidates, num_moves, replace=False, p=move_probs)
        # 从最高层开始，找到一个有效的落子，不会减少视野空间
        for point_index in ranked_moves:
            point = self.encoder.decode_point_index(point_index)
            if game_state.is_valid(goboard.Move.play(point)) and \
                    not is_point_true_eye(game_state.board, point, game_state.current_player):
                return goboard.Move.play(point)
        return goboard.Move.pass_turn()

9.4.自我对弈：一个计算机程序该怎么做？

现在你有了一个能够完成游戏的学习代理，你可以开始收集经验数据。对于围棋AI来说，这意味着要玩成千上万的游戏。本节介绍如何实现这一过程。首先，我们描述了一些数据结构，使处理经验数据更加方便。接下来，我们将展示如何实现自我对弈驱动程序。

9.4.1.表示经验数据 

经验数据包含三个部分：状态、行动和回报。为了有效组织这三个部分，您可以创建一个单独的数据结构，将它们放在一起。

ExperienceBuffer类是一个经验数据集的最小容器。它有三个属性：状态、行动和奖励。所有这些都被表示为NumPy数组；您的代理将负责编码它的状态和动作作为数据结构。ExperienceBuffer只是一个容器，用来传递数据集。在这种实现中，没有任何特定的策略梯度学习。在后面的章节中，您可以使用其他强化学习算法来重用这个类。因此，您需要将此类添加到dlgo/rl/experience.py模块中。 

class ExperienceBuffer:

    def __init__(self, states, actions, rewards):
        self.states = states
        self.actions = actions
        self.rewards = rewards

现在，您有了一个简单的容器来传递经验数据。你仍然需要一种方法来填充你的经纪人的决定。复杂的是代理人一次只做一个决定，但是直到比赛结束，当你知道谁赢了，它才会得到奖励。要解决这个问题，您需要跟踪当前变化下的所有决定，直到它完成。一种选择是把这个它的逻辑直接放到代理中，但这会扰乱PolicyAgent的实现。或者，你可以把这个分离成一个独立的ExperienceCollector对象。

这个ExperienceCollector实现了四种方法：

• begin_episode和complete_episode，这两种方法被自我游戏驱动程序调用，以指示一个简单游戏的开始和结束。
• record_decision，它被代理调用以指示它选择的单个操作。
• to_buffer将ExperienceCollector所记录的所有内容打包并返回ExperienceBuffer。自我对弈驱动程序将在自我游戏会话结束时调用它。完整的实现如下。

class ExperienceCollector:

    def __init__(self):
        self.states = []
        self.actions = []
        self.rewards = []
        self.current_episode_states = []
        self.current_episode_actions = []

        def begin_episode(self):
            self.current_episode_states = []
            self.current_episode_actions = []

        # 记录当前的决定和行动
        def record_decision(self, state, action):
            self.current_episode_states.append(state)
            self.current_episode_actions.append(action)

        def complete_episode(self, reward):
            num_states = len(self.current_episode_states)
            # +=用在列表表示连接列表
            self.states += self.current_episode_states
            self.actions += self.current_episode_actions
            # 给游戏中从episode开始到结束时的每一个动作都分配最后的回报(赢是1，输是-1)
            self.rewards += [reward for _ in range(num_states)]
            self.current_episode_states = []
            self.current_episode_actions = []

        # 将python列表转成numpy矩阵，然后返回ExperienceBuffer
        def to_buffer(self):
            return ExperienceBuffer(states=np.array(self.states),
                                    actions=np.array(self.actions),
                                    rewards = np.array(self.rewards))

9.4.2.模拟游戏

下一步是玩游戏。您已经在本书中做过两次这样的操作：在第3章中的bot_v_bot演示中，以及在第4章实现的蒙特卡洛模拟评估。您可以在这里使用相同的stimulate_game实现。 

def simulate_game(black_player, white_player,board_size):
    moves = []
    game = GameState.new_game(board_size)
    agents = {
        Player.black: black_player,
        Player.white: white_player,
    }
    while not game.is_over():
        next_move = agents[game.current_player].select_move(game)
        moves.append(next_move)
        game = game.apply_move(next_move)

    print_board(game.board)
    game_result = compute_game_result(game)
    print(game_result)

    return GameRecord(
        moves=moves,
        winner=game_result.winner,
        margin=game_result.winning_margin,
    )

 你也可以用一个自己的副本与自己对弈。除了这种解决方案的简单性外，还有两个具体的优点。

首先，强化学习需要兼顾成功和失败的教训。想象下你的第一盘棋或与大师对决。作为一个新手，你将远远落后于对手，这时你不可能知道哪里错了，而有经验的棋手可能会犯几个错误，但仍然可以轻松获胜。因此，两位棋手都不会从比赛中学到很多东西。取而代之的，初学者一开始通常会与其他初学者对局，然后慢慢提升对手水平。同样的原理也适用于强化学习，当你的AI与自己对弈的时候，它总是会有一个同等水平的对手。

第二，让你的AI与自己对弈，这样你花一个AI的时间得到两场游戏的经验。因为游戏双方有同样的决策过程，你可以从赢方和输方两方面学习。因为你需要进行大量的游戏来强化学习，因此获得两倍的速度是一个很好的方案。

为了开始自我对弈过程，您需要构造了两个副本，并为它们都分配一个ExperienceCollector。每个代理都需要自己的收集器，因为两个代理在游戏结束时会看到不同的回报。清单9.19展示了这个初始化步骤。

游戏之上强化学习

自我对弈是收集棋盘游戏经验数据的一种很好的技术。在其他领域中，您需要单独构建一个模拟环境来运行您的代理。例如，你想要使用强化学习为机器人构建控制系统，您需要对机器人将在的物理环境进行详细的模拟。

如果你想用强化学习进一步试验，OpenAI Gym（https://github.com/openai/gym）是一个有用的资源。它为各种棋盘游戏、视频游戏和物理模拟提供了环境。

  # 开始模拟对局
    for i in range(num_games):
        collector1.begin_episode()
        collector2.begin_episode()
        game_record = simulate_game(agent1,agent2,board_size)
        # 黑棋赢了给第一个AI回报1，给第二个AI回报-1
        if game_record.winner == Player.black:
            collector1.complete_epoisode(reward=1)
            collector2.complete_epoisode(reward=-1)
        # 白棋赢了给第一个AI回报-1，给第二个AI回报1
        else:
            collector1.complete_epoisode(reward=-1)
            collector2.complete_epoisode(reward=1)

        experience = combine_experience([collector1,collector2])
        with h5py.File(experience_filename, 'w') as experience_outf:
             experience.serialize(experience_outf)

此时，你已经准备好产生自我对弈游戏了。下一章将向您展示如何从自我对弈数据中去改进你的机器人。

9.5.摘要 

• 一个代理是一种计算机程序，它能支持完成某项任务。比如，我们的围棋对弈AI就是一个以赢得围棋游戏为目标的AI。
• 强化学习周期涉及到收集经验数据，从经验数据中训练代理，并评估更新的代理。在一个周期结束时，您期望您的代理的性能有一个小的改进。理想情况下，你可以重复这个周期很多次，从而不断提高你的代理人。
• 要将强化学习应用于问题，你必须用状态、行动和回报来描述问题。
• 回报是你控制强化学习行为的方式。你可以为你希望你的代理人实现的结果提供积极的回报，为你想要避免的结果提供消极的回报。
• 一个政策是从给定游戏状态作出决策的规则。在围棋AI中，从给定的棋盘局面去选择落子的算法是其策略。
• 你可以用神经网络来制定一个策略，通过将输出向量视为可能落子的概率分布，然后从概率分布中采样。
• 当把强化学习应用到游戏中时，你可以选择通过自我对弈来体验数据：你的代理将和自己的副本玩游戏。 

 

运行其中一局截图（.是空,o是黑，x是白,结果该局自我对弈白胜）

19  o  o  .  o  o  o  o  .  o  .  o  .  o  .  o  o  o  .  o 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
18  o  o  o  o  o  .  o  o  o  o  o  o  o  o  o  o  o  o  o 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
17  o  o  o  o  o  o  o  o  o  o  x  x  x  o  .  o  o  o  o 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
16  o  .  o  o  .  o  .  o  o  x  x  x  x  o  o  o  o  o  . 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
15  o  o  o  o  o  o  o  o  o  x  x  x  o  o  o  o  .  o  o 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
14  o  o  o  o  o  x  x  x  o  o  x  x  x  x  x  x  o  o  o 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
13  o  .  o  o  x  x  x  x  x  x  x  x  x  x  x  x  o  o  o 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
12  x  o  o  o  o  o  x  x  x  x  x  o  o  o  x  o  o  o  o 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
11  x  x  o  o  x  x  .  x  x  .  x  o  o  o  o  o  o  .  o 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
10  x  x  x  x  .  x  x  x  x  x  x  x  x  o  .  o  o  o  o 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
 9  x  .  x  x  x  x  .  x  x  x  x  x  x  o  o  .  o  .  o 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
 8  x  x  x  x  .  x  x  x  x  .  x  o  o  o  o  o  o  o  o 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
 7  .  x  .  x  x  x  .  x  x  x  x  o  .  o  x  o  o  o  o 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
 6  x  x  x  x  x  x  x  x  x  x  o  o  o  o  x  o  o  o  x 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
 5  x  x  x  x  x  .  x  o  o  o  o  o  x  x  x  x  o  x  x 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
 4  x  .  x  x  .  x  x  o  o  .  o  o  o  o  x  x  x  x  x 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
 3  x  x  .  x  x  x  o  o  o  o  o  o  .  o  o  x  x  x  x 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
 2  .  x  x  x  x  o  o  o  .  o  o  o  o  o  x  .  x  .  x 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
 1  x  x  x  x  o  o  o  o  o  o  o  o  .  o  x  x  x  x  x 
    A  B  C  D  E  F  G  H  J  K  L  M  N  O  P  Q  R  S  T
W+43.5

10局自我对弈后文件保存成experience.h5